Реферат: Взаимосвязь языков C и ассемблера
💣 👉🏻👉🏻👉🏻 ВСЯ ИНФОРМАЦИЯ ДОСТУПНА ЗДЕСЬ ЖМИТЕ 👈🏻👈🏻👈🏻
В создаваемых
ассемблерных
программах
можно использовать
все регистры
процессора.
Но чтобы предотвратить
путаницу с
функциями С
и С++, необходимо
восстанавливать
bp, cs, sp и ss, которые
они имели до
запуска созданной
подпрограммы.
Тогда можно
быть совершенно
уверенным, что
обращение к
другим функциям
не изменит эти
регистры. Также
нельзя забывать,
что С использует
регистры si и
di для регистровых
переменных,
поэтому при
использовании
встроенного
ассемблера
замедляется
общая работа
программы.
К регистрам
ax, bx, cx, dx и es можно
обращаться
свободно и не
нужно резервировать
их значения
до окончания
подпрограммы.
Эта свобода
касается и
других функций,
поэтому надо
помнить, что
эти регистры
изменяться,
если вызываются
функции С и С++
из ассемблерных
подпрограмм.
Ассемблерные
операторы
inline начинаются
словом asm, за
которым следует
инструкция
и ее операнды.
Например, чтобы
синхронизировать
программу с
внешним сигналом
прерывания,
можно написать:
Когда ранние
версии Turbo C компилируют
программу со
встроенными
командами asm,
компилятор
сперва создает
ассемблерный
текст для всей
программы,
вставляя в
текст наши
ассемблерные
инструкции
вместе с откомпилированным
кодом для остальных
операторов
С. Затем компилятор
вызывает Turbo
Assembler и Linker (компоновщик),
чтобы провести
ассемблирование
и подключить
программу к
конечному файлу
кода. Более
поздние версии
Turbo и Borland C++ могут
компилировать
операторы asm
без вызова
TASM. Полный синтаксис
asm:
asm[метка]
мнемоника/директива
операнды [;] [/*С
комментарий*/]
Точки с запятыми
в конце строк
asm и комментарии
С, расположенные
между /*и*/ удаляются
из текста перед
ассемблированием,
поэтому их
можно опускать
в тексте программы.
1.3 Размещение
данных и операторов
в тексте программы
Каждая строка
текста программы
С и С++ находится
либо внутри,
либо снаружи
функции, и операторы
asm могут вставляться
как в одном,
так и в другом
месте. Конкретное
положение
оператора asm
влияет на то,
куда ассемблируется
код или директива.
Если оператор
asm появляется
снаружи функции,
то он ассемблируется
в сегмент данных
программы, если
внутри функции
- в кодовый сегмент.
Обычно, чтобы
создать переменные,
операторы asm
вставляются
снаружи функций;
для создания
кода их следует
вставлять
внутрь функций.
Например:
asm shl [count], 1/*умножение
count на 4*/
Переменная
count объявляется
в сегменте
данных программы
(относительно
ds). Операторы
внутри функции
main умножают count
на 4, используя
вместо mul быстрые
инструкции
сдвига shl. Если
объявлять
переменные
внутри функции,
данные ассемблируются
в кодовый сегмент,
требуя особого
обхождения:
asm shl [count], 1 /* умножение
count на 4*/
Поскольку
теперь переменная
count находится
в кодовом сегменте,
требуется
инструкция
jmp, чтобы избежать
случайного
восприятия
значения count в
качестве машинного
кода и его
исполнения.
Inline операторы
asm имеют свободный
доступ к переменным
и структурам
С и C++ - одно из
самых привлекательных
преимуществ
метода inline по
сравнению с
подходом посредством
внешних модулей.
Самое интересное
в типах данных
ассемблера
и С++, что dq может
использоваться
для создания
инициализированных
переменных
двойной длины
с плавающей
точкой в языке
ассемблера,
но в Turbo Assembler отсутствуют
директивы для
непосредственного
создания переменных
с плавающей
точкой.
В операторах
asm можно ссылаться
на переменные
типов С++. Например:
asm mov dl, [initial] /*Загрузка
символа в dl*/
asm mov ah, 2 /* Пересылка
символа в ДОС
*/
asm int 21h /* Стандартная
выходная функция
*/
Беззнаковая
символьная
переменная
initial загружается
оператором
asm в dl. Так как и
dl, и беззнаковые
символьные
данные имеют
длину один
байт, нет необходимости
в ссылке использовать
определитель
Byte, хотя его применение
и не будет ошибкой:
Можно объявить
переменные
для использования
только ассемблерными
операторами.
Например, чтобы
создать 16-битовое
слово с именем
TwoBytes и загрузить
значение переменной
в сх, можно написать:
Переменная
TwoBytes объявляется
в сегменте
данных программы
(снаружи функции),
с использованием
директивы db,
чтобы хранить
в памяти 2 байта
(1 и 2). Оператор
ассемблера
затем загружает
TwoBytes в сх. Определитель
Wordptr необходим
для ссылки на
TwoBytes как на 16-битовое
слово.
Поскольку
TwoBytes объявляется
в операторе
asm, на эту переменную
нельзя ссылаться
в тексте программы
С или C++. Поэтому,
если только
не требуются
отдельные
переменные
для ассемблерных
инструкций,
следует объявлять
их обычным
образом и ссылаться
на них из ассемблерного
модуля.
Ассемблерные
операторы
inline могут вызывать
функции С и
C++, а операторы
С и C++ обращаться
к функциям,
написанным
полностью на
ассемблере.
Вся эта взаимосвязь
будет хорошо
рассмотрена
в данном курсовом
проекте.
Раздел 3: Вызов
ассемблерных
функций из С
Как показывает
практика, все
символы PUBLIC и
EXTERN должны начинаться
символами
подчеркивания.
Это необходимо
делать только
в ассемблерном
модуле (но не
в исходной про
грамме С или
C++), поскольку
компилятор
добавляет
подчеркивание
ко всем глобальным
символам, если
только не
используется
опция -u для
компиляции
программ. (Не
стоит применять
эту опцию, если
только не надо
также перекомпилировать
всю используемую
при выполнении
С библиотеку,
в которой
предполагается,
что все глобальные
символы начинаются
символом
подчеркивания.)
Если во время
компоновки
выходит сообщение
об ошибке "undefined
symbol" (неопределенный
символ), то причиной
может оказаться
отсутствие
подчеркивания
в ассемблерном
модуле.
Если объявляются
переменные
в дальнем сегменте
данных после
ключевого слова
FARDATA, то необходимо
подготовить
сегментный
регистр к размещению
переменных
в памяти. Прежде
всего, вслед
за директивой
FARDATA необходимо
объявить данные:
Затем, в кодовом
сегменте, следует
перед использованием
переменной
подготовить
сегментный
регистр. Одним
из возможных
подходов является
использование
оператора SEG
для загрузки
адреса дальнего
сегмента данных:
mov ax, SEG_OuterLimits;Адресует
дальний сегмент
;данных
mov es, ах
;посредством
es
mov [es:_OuterLimits], dx ;Резервируется
dx для пере ;менной
Можно также
использовать
заранее определенный
символ @fardata:
Чаще всего
asm код оформляют
в виде отдельных
asm функций, которые
потом соединяют
на этапе загрузки.
Ассемблерный
код должен
поддерживать
стиль языка
С для вызова
функций, которые
включают передачу
параметров,
возврат значений
и правила сохранения
регистров,
которые требуются
для С++ функций.
Компилятор
и загрузчик
должны работать
совместно для
обеспечения
вызовов между
модулями. Процесс
называется
исключением
или ломкой
имен. Предусматривает
наличие информации
о типе аргумента.
Ломка имени
изменяет имя
функции, показывая,
что за аргумент
принимает
функция. Когда
мы конструируем
на языке С++, то
ломка имен
происходит
автоматически.
Когда же
пишется модуль
на asm, который
должен быть
подсоединен
к модулю на
языке С++, необходимо
позаботиться
о том, чтобы
asm модуль содержал
ломку имен
(знак подчеркивания).
Это можно сделать
путем написания
фиктивной
функции на С++
и компилировать
его в asm код. И
ассемблерный
файл, который
будет сгенерирован
компилятором
С++, будет содержать
ломку имен,
которые мы
можем потом
использовать
при написании
asm функции:
@ имя класса
@ исходное имя
функции $g описание
типов
g - начало описания
типов параметров
BC++ разрешает
использование
неискаженных
имен asm функций,
определяя
стандартные
имена С функций
в С программах.
Для этого в
программе
определяется
внешний С блок:
Определение
или декларирование
asm функции во
внешнем С блоке
избавляет
программиста
от необходимости
определения
действительного
имени ассемблерной
функции и повышает
наглядность.
С++ передает
параметры
функции через
стек. Перед тем
как вызвать
функцию С++ помещает
параметры в
стек, начиная
с последнего.
3.4 Ассемблирование
и компоновка
внешних модулей
Существует
несколько
методов ассемблирования,
компиляции
и компоновки
отдельных
модулей (и
аналогичных
многофайловых
программ) для
создания конечной
.ЕХЕ программы.
Проще всего
предоставить
проделать все
это Turbo С:
tcc cfillstr cfill.asm/*первый
модуль - cfillstr.c*/
Если используется
Borland C++, надо ввести
следующую
команду (заменить
bсс на tсс для
Turbo C++):
В любом случае
команда сперва
компилирует
CFILLSTR.C в CFILLSTR.OBJ. Затем,
распознав
расширение
имени файла
.ASM как имя ассемблерного
модуля, компилятор
вызывает Turbo
Assembler, чтобы ассемблировать
CFILL.ASM в CFILL.OBJ. И наконец,
компилятор
вызывает Turbo Linker
для объединения
модулей с объектными
кодами в CFILLSTR.EXE. Если
компиляции
и ассемблированию
подлежит небольшое
количество
модулей, этот
одношаговый
метод наиболее
прост для
использования.
Если у имеется
большое количество
модулей, можно
сэкономить
время, осуществляя
ассемблирование
и компоновку
раздельно.
Первым шагом
следует ассемблировать
все .ASM файлы.
Поскольку
пример flllsrting обладает
только одним
таким файлом,
все можно проделать
с помощью
единственной
команды
Опция /ml включает
различение
строчных и
прописных
символов, чтобы
к примеру слова
UpAndDown и upanddown рассматривались
как различные
- как это принято
в программах
С и C++. (Turbo Assembler обычно
не обращает
внимания на
то, в каком регистре
набраны символы,
поэтому опция
/ml необходима
во избежание
ошибок при
компоновке.)
После ассемблирования
всех внешних
модулей откомпилировать
основную программу.
Опять же, поскольку
в этом примере
имеется только
один файл .С,
для этого необходима
только одна
команда
Если используется
Borland C++, надо применить
следующую
команду (заменить
bсс на tсс для
Turbo 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 этим методом
требуются три
команды:
Для Borland C++ надо
ввести следующие
команды (заменить
bсс на tсс для
Turbo C++):
Первые две
команды - те
же, что были
описаны выше.
Третья вызывает
компилятор
во второй раз,
используя опцию
-ms для определения
модели памяти,
в данном случае
small (малая). Вслед
за опцией модели
памяти идут
файлы с объектным
кодом, подлежащие
компоновке.
Хотя приходится
включать расширение
имен файлов
.OBJ в перечисление
каждого файла,
этот не очень
длинный метод
компоновки
упрощает большую
часть черновой
работы по
непосредственному
запуску Turbo Linker. Для
того, чтобы
узнать, какую
опцию надо
писать при TCC,
можно воспользоваться
следующей
таблицей.
Таблица
3.1: Имена файлов
рабочей библиотеки
Раздел 4: Вызов
функций С из
языка ассемблера
До сих пор
рассматривалось,
как разделить
переменные
между С или C++
и ассемблером,
а также как
вызывать внешние
ассемблерные
функции из
программ, написанных
на С или C++. Теперь
подойдем к
этому с другой
стороны, т.е. к
вызову функций
С или C++ из ассемблерного
модуля - это
также возможно,
но требует
большего внимания.
Если функция
не обладает
параметрами,
процесс достаточно
прост. Надо
объявить функцию
С или C++ в директиве
EXTRN и воспользоваться
инструкцией
call:
Здесь предполагается,
что функция,
названная
_cfunction, существует
в программе,
подлежащей
компоновке
вместе с ассемблерным
модулем.
Если функции
требуются
параметры,
процесс усложняется.
Простые параметры,
такие как символы
и целые числа
часто передаются
непосредственно
в стек. Сложные
переменные,
такие как строки,
структуры и
множества,
передаются
посредством
ссылок, т.е. по
адресу. Кроме
того, многие
функции возвращают
результат в
специфичные
регистры. При
вызове функций
С или C++ из языка
ассемблера
надо самим
позаботиться
о подобных
нюансах.
Сперва рассмотрим
простейший
случай вызова
функции с одним
целочисленным
параметром:
printf(“\nThe score is: %d\n, thescore);
Чтобы вызвать
функцию showscore из
ассемблерного
модуля, передавая
значение переменной
типа слова в
качестве thescore,
можно написать:
mov ах, 76 ;
Присвоение
score регистру
push ах ;
Передача параметра
в стек
call _showscore ; Вызов
функции С
pop ах ;
Фиксация стека
Прежде всего,
значение score
присваивается
ах (любой другой
регистр точно
так же подойдет
для этого), а
затем выталкивается
в стек перед
вызовом showscore. После
возврата из
функции слово
выталкивается
из стека. Это
необходимо
потому, что в
С и C++ вызывающая
программа
удаляет параметры
из стека. Если
имеется несколько
параметров,
может быть,
будет лучше
просто прибавить
их общее число
байтов к sp. Например,
чтобы вызвать
функцию, которая
оперирует
четырьмя 16-битовыми
параметрами,
можно воспользоваться
следующими
командами:
push [vl] ; Выталкивание
четырех переменных
push [v2] ; (не показанных)
в стек
add sp, 8 ; Удаление
параметров
Выталкивание
нескольких
параметров
осуществляется
в порядке, обратном
тому, в каком
они объявляются
функции С или
C++. Исходя из
предположения,
что функция
fillstring определена
как
void fillstring( unsigned char far *thestring, int
stringLength, char fillchar );
для вызова
этой функции
из языка ассемблера
и заполнения
строковой
переменной
пробелами
требуются
несколько
шагов. Сперва
ассемблерный
модуль объявляется
строковой
переменной:
Затем этот
же модуль объявляет
fillstring в директиве
EXTRN и вызывает
функцию для
заполнения
строчной переменной
пробелами:
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++ ничем не
отличаются.
В дополнение
к переменным,
объявленным
в сегменте
данных либо
общим с программой
С и С++, можно
использовать
локальные
переменные,
помещенные
в стек создаваемых
ассемблерных
модулей. Локальные
переменные
существуют
только во время
выполнения
функции. Стековая
часть создается
для переменных
при запуске
функции, а затем
очищается перед
ее завершением.
Таким образом,
другие функции
могут использовать
эти же области
памяти для
своих собственных
локальных
переменных,
снижая общий
объем памяти,
требуемой для
всей программы.
Например:
Целая переменная
i помещается
в памяти в стек
при запуске
функции countup и
существует
только до тех
пор пока выполняется
эта функция.
В ассемблерном
модуле можно
проделать тоже
самое с помощью
директивы
LOCAL. Вот пример
законченной
функции:
;--Код, использующий
локальную
переменную
[i]
Директива
LOCAL в этом примере
подготавливает
переменную
i типа Word (слово).
Указание = stacksize
назначает общее
число байтов,
занимаемое
всеми локальными
переменными
- в данном случае
2 байта. Это значение
вычитается
из sp после подготовки
адресации
переменных
в стек. Затем,
для ссылки на
i, используются
такие инструкции,
как mov, inc и crop. Благодаря
директиве LOCAL
ссылки типа
[i] переводятся
следующим
образом:
и т.д. При
использовании
LOCAL нет необходимости
вычислять
отрицательные
смещения относительно
bp, чтобы определить
местоположение
переменных
в стеке, -достаточно
воспользоваться
именами переменных.
Поскольку
bp не изменяется
во время выполнения
этой функции,
можно восстановить
sp по средством
bp, удаляя область
локальной
переменной
из стека, или
прибавить
stacksize к sp с помощью
команды
Подходят
оба метода, но
восстановление
sp посредством
bp - быстрее. Можно
также объявить
несколько
локальных
переменных
операторами,
подобными
следующему:
LOCAL i:Word; j:Word; c:Byte=stacksize
Теперь, после
вычитания
stacksize из указателя
стека для
резервирования
области в стеке,
можно использовать
три локальные
переменные
- i, j и с. (Необходимо
всегда делать
LOCAL, что упрощает
адресацию
локальных
переменных,
это не создает
область для
переменных
в памяти.)
Совместное
использование
C++ и ассемблера
становится
более сложным,
когда к функциям
добавляются
аргументы.
Приходится
очень внимательно
программировать,
обращаясь к
функциям из
различных
модулей и выбирая
аргументы из
стека. Но следующая
директива берет
на себя задачу
сама произвести
ломку имен и
занести их в
стек:
Аргументы,
перечисленные
таким образом,
не являются
объектами
данных; они
смещаются в
стеке относительно
регистра bр.
Использование
ARG подобным образом
позволяет
ассемблеру
вычислить
смещения вместо
нас - но мы должны
специфицировать
правильные
типы данных.
Символьная
переменная
в C++ является
байтом в ассемблере,
целая в C++ - эквивалентом
ассемблерного
слова и т.д.
Обратный
процесс - передача
аргументов
из языка ассемблера
в C++ - требует иной
тактики:
proc _asmfunction C c_arg:byte, k_arg:word
“C” после
имени функции
указывает, что
аргументы
приводятся
для языка С
(т.е. они выталкиваются
в стек в порядке
справа налево).
Остальное
также, как и
для директивы
ARG.
В результате
Turbo Assembler автоматически
пишет инструкции
для сохранения,
инициализации
и восстановления
bp. При использовании
этой альтернативной
методики не
приходится
проводить
точные операции
по выталкиванию
bp. За исключением
этого отличия,
в остальном
процесс программирования
остается тем
же самым.
В курсовой
требовалось
написать программу,
вычисляющую
значение многочлена
n-ой степени по
вектору размерности
n коэффициентов
многочлена
и по некой переменной
х, задаваемые
пользователем.
Необходимо
было реализовать
многомодульную
связь (два модуля:
на С и на ассемблере),
а также выразить
наглядно связь
ассемблера
с языком С.
Программа
реализовывалась
по следующей
блоксхеме:
Очевидно,
что была реализована
связь в обе
стороны.
/*Это часть
на С++, есть еще
на ассемблере*/
extern "C" void vvod();/*ассемблерная
процедура*/
extern "C" void mnogochlen(int *vec);/*функция
в С*/
extern int *vect;/*вектор
коэффициентов,
объявленный*/
cout<<"\n Введите
степень многочлена:"<
vvod();/*Вызов
ассемблерной
процедуры*/
cout<<"\n Введите
значение
переменной:"<
for(i=m;i>=0;i--)/*Вычисление
ответа*/
so db 'введите
вектор коэффициентов','$'
extrn _m:word, _vec:word; Внешние
аргументы
extrn _mnogochlen:proc; функция
из С++
push di;Сохранение
значений этих
регистров
push si;необходимо,
т.к. они используются
С++
MOV ah,09h ;начало
ввода вектора
перестановок
ADD si,2;Данные
типа слово,
прибавляем
2
pop di;извлечение
сохраненных
регистров
call _mnogochlen; Вызов
функции С++
ADD sp,4;Удаление
элементов из
стека
При работе
в многомодульном
режиме главные
трудности
возникают в
использовании
регистров.
Из-за несохранения
системных
регистров,
используемых
С++, программа
может просто
“повиснуть”.
Также следовало
сделат выбор
- какой модуль
сделать главным.
Но практика
показывает,
что следует
производить
вызов языков
низкого уровня
из высокого,
а не наоборот.
В общем, все
трудности были
преодолены
и программа
появилась в
свет.
В идеальном
мире программирования
компиляторы
с языков высокого
уровня должны
генерировать
самый быстрый,
самый компактный
и наилучший
машинный код
для любой программы.
Если бы это
было невозможно,
то программирование
много бы потеряло
от этого, и наверняка
не писался бы
этот курсовик.
Но это невозможно.
Несмотря на
множество
усовершенствований
при разработке
компиляторов,
ни один язык
высокого уровня
пока не в состоянии
продублировать
краткий, быстрый
и изящный код,
написанный
опытным специалистом
по ассемблеру.
В чем же дело?
А в том, что
компиляторы
обобщают решаемые
ими задачи. В
C++ существует
только один
способ написания
цикла FOR. В то же
время с помощью
ассемблера
этот цикл можно
организовать
с помощью ассемблера
этот цикл можно
организовать
десятками
способов. Чтобы
компилятор
выбирал идеально
подходящие
в каждой конкретной
ситуации методы
реализации
алгоритма и
при этом учитывая
их влияние на
остальные части
программы - он
должен обладать
интеллектом
гения, вкусом
художника и
интуицией
предсказателя.
Сегодняшние
компиляторы
с языков высокого
уровня достаточно
сообразительны,
но не до такой
степени.
Среди всех
существующих
компиляторов
С наиболее
приблизился
к идеалу С++.
Порождаемый
им машинный
код работает
достаточно
быстро, занимает
на диске немного
места и в большинстве
случаев может
использоваться
без каких-либо
модификаций.
Однако несмотря
на все достоинства
С++, все равно
остается место
для улучшений,
благодаря чему
даже небольшие
участки программы,
переписанные
на ассемблере,
могут значительно
повысить скорость
работы программы
и уменьшить
размер исполняемого
файла. Кроме
того, добавив
ассемблер к
С++, можно облегчить
доступ к регистрам
аппаратных
средств и решение
других задач
низкого уровня,
таких как запись
символов
непосредственно
в видеопамять.
Во многих
случаях единственный
способ для
прибавления
программе
скорости - немного
дополнить
совершенный
“С”, используя
один из двух
методов:
Использование
встроенных
операторов
(операторов
Inline)
Операторы
Inline вставляют
язык ассемблера
непосредственно
в исходную
программу на
С и С++. Эта методика
быстрая и простая,
но имеет несколько
недостатков,
которые поясняться
ниже. Внешние
функции, хотя
их и трудно
использовать,
чем операторы
Inline, имеют то
преимущество,
что позволяют
наиболее полно
использовать
все возможности
Turbo Assembler.
1. Том Сван
“Освоение Turbo
Assembler”, Диалектика,
Киев, 1996 г.
2. Березин
Б.И., Березин
С.Б. “Начальный
курс С и С++”, Диалог
МИФИ, Москва,
1996 г.
3. Лекции Комлевой
Нины Викторовны
по предмету
“Языки программирования
и методы трансляции”
МОСКОВСКИЙ
ГОСУДАРСТВЕННЫЙ
УНИВЕРСИТЕТ
ЭКОНОМИКИ,
СТАТИСТИКИ
И ИНФОРМАТИКИ
на тему :
“Взаимосвязь
языков С и
ассемблера”
Название: Взаимосвязь языков C и ассемблера
Раздел: Рефераты по информатике, программированию
Тип: реферат
Добавлен 11:23:35 05 июля 2005 Похожие работы
Просмотров: 1119
Комментариев: 16
Оценило: 4 человек
Средний балл: 5
Оценка: неизвестно Скачать
1.3 Размещение
данных и операторов
в программе
Раздел
3: Вызов ассемблерных
функций из С
3.4 Ассемблирование
и компоновка
внешних модулей
Раздел
4: Вызов функций
С из ассемблера
Срочная помощь учащимся в написании различных работ. Бесплатные корректировки! Круглосуточная поддержка! Узнай стоимость твоей работы на сайте 64362.ru
Если Вам нужна помощь с учебными работами, ну или будет нужна в будущем (курсовая, дипломная, отчет по практике, контрольная, РГР, решение задач, онлайн-помощь на экзамене или "любая другая" учебная работа...) - обращайтесь: https://clck.ru/P8YFs - (просто скопируйте этот адрес и вставьте в браузер) Сделаем все качественно и в самые короткие сроки + бесплатные доработки до самой сдачи/защиты! Предоставим все необходимые гарантии.
Привет студентам) если возникают трудности с любой работой (от реферата и контрольных до диплома), можете обратиться на FAST-REFERAT.RU , я там обычно заказываю, все качественно и в срок) в любом случае попробуйте, за спрос денег не берут)
Да, но только в случае крайней необходимости.
Реферат: Взаимосвязь языков C и ассемблера
Реферат На Тему Основополагающие Принципы Формирования Мотивации Персонала Организации
Джек Лондон Сочинения Купить
Контрольная работа по теме Системы автоматического управления тепловых двигателей
Цифровая Железная Дорога Реферат
Реферат: Сировинні проблеми світового господарства
Сочинение За Что Я Люблю Стихи Пушкина
Катерина Сильная Или Слабая Личность Гроза Сочинение
Курсовая работа: Культура древних обществ Востока
Доклад по теме Кобаламин (витамин В12)
Официальный Сайт Сочинения Без Срока Давности
Как Напишется Шестиклассник Сочинение Моя Комната
Подготовиться К Сочинению Описание Внешности Человека
Доклад: Понятие признания и его формы
Эссе Адам Репродуктивті Денсаулығы
Эсс 40.60 Rw Ухл1
Сочинение Рассуждение На Тему Время Перемен
Курсовая работа по теме Моделирование организации
Биология И Сельское Хозяйство Реферат
Эссе Моя Цель Участия В Кадровом Резерве
Курсовая работа: Массовая культура. Древний Рим. Скачать бесплатно и без регистрации
Реферат: Этическая философия Г. Сковороды /Укр./
Реферат: Интегральная телесная терапия - новый взгляд на процесс и результат
Сочинение: Толстой Л.Н.