1 2 Программа построение графика

Введение

Курсовой проект (программа) был разработан на языке ассемблер с использованием средств этого языка. Язык ассемблер позволяет работать с компьютером на низшем уровне, то есть с микропроцессором. Язык ассемблера является символическим представлением машинного языка, он неразрывно связан с архитектурой самого процессора. По мере внесения изменений в архитектуру процессора совершенствуется и сам язык ассемблера. График построен на языке C# . В пояснительной записке представлен листинг программы, алгоритм с описанием, результаты компиляции программы.

1 Постановка задачи

1.1 Основная программа

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

При выполнении курсовой работы использовать операционную систему Windows, инструментальные программы ассемблер (TASM, MASM). Для графических построений можно использовать C#.

Согласно номеру варианта 14 данного курсового проекта, номера байтов — 23 и 25, номера битов, которые необходимо извлечь, — 1 и 7, соответственно.

1.2 Программа построение графика

Написать программу, которая строит график сформированных слов, находящихся в файле Result.dat. На оси x откладываются номера байтов, на оси y их значения

2 Краткие теоретические сведения

2.1 Ассемблер, язык ассемблера

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

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

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

Источник



Ассемблер

Начало программы начинается с распределения памяти под код программы под данные и под стек. Прописав строку Model Small выделяется по 64кБ под данные и под код. В задании нам необходимо работать с 32-х битными переменными для чего прописываем строку .386.

Определившись с основными моментами начинаем ввод переменных. Переменной является x.

Ввод переменной x и обработка осуществляется в несколько этапов. Вначале вводится код числа стандартным прерыванием int 21 функцией 0Ah, замет берётся каждый символ и преобразуется в десятичное значение и осуществляется определение десятков или единиц соответственно. В результате получаем введённое нами десятичное число.

Следующим этапом является вычисление полинома по формуле у=2* x-6y- 4. Во-первых возводим в квадрат “x”, затем умножаем на 2. Потом суммируем полученные значения и помещаем в переменную у, которая и является ответом данной задачи.

Завершающей стадией программы являются вывод переменной у и завершение программы. Вывод переменной осуществляется функцией outword, которая содержится в подключаемом модуле io.asm. Подключение данного модуля осуществляется командной include прописываемая до кода программы. Завершение программы осуществляется стандартным способом по стандартному DOS-кому прерыванию int 21 функцией 4Сh.

Рис. 1. Схема алгоритма.

Вначале рассмотрим схему хранения операций ввода-вывода (ВВ) и подключения их к программам:

Часть операций ввода-вывода реализована в виде процедур, описания которых собраны в отдельном модуле, хранящемся в файле с именем ioproc.asm (текст модуля приведён ниже). Предполагается, что этот модуль заранее оттранслирован и в виде объектного модуля записан в файл с именем ioproc.obj.

Изменения стека во время прогона программы

Стек в данной программе при выводе переменной у нам необходимо было освободить 6 байт стека для вывода числа.

SP указатель стека. SS стек.

Приведём пошаговое изменение стека:

SP: 00F0 SS: 00F2 0000

SP: 00F2 SS: 00F4 13BA

SP: 0F4 SS: 00F6 0000

SP: 00F6 SS: 00F8 00C9

SP: 00F8 SS: 00FA 1645

SP: 0100 SS: 0102 02B4

2. Область применения.

Программа применяется для расчета полинома у=2* x-6y- 4. Программа имеет ограничения в применении, потому что в ней применяется расчет одного значения и по одному алгоритму.

Источник

Язык ассемблер. Команды и основы ассемблера

В статье будут рассмотрены основы языка ассемблер применительно к архитектуре win32. Он представляет собой символическую запись машинных кодов. В любой электронно-вычислительной машине самым низким уровнем является аппаратный. Здесь управление процессами происходит командами или инструкциями на машинном языке. Именно в этой области ассемблеру предназначено работать.

Программирование на ассемблер

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

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

Регистры

Регистрами в языке ассемблер называют ячейки памяти, расположенные непосредственно на кристалле с АЛУ (процессор). Особенностью этого типа памяти является скорость обращения к ней, которая значительно быстрее оперативной памяти ЭВМ. Она также называется сверхбыстрой оперативной памятью (СОЗУ или SRAM).

Существуют следующие виды регистров:

  1. Регистры общего назначения (РОН).
  2. Флаги.
  3. Указатель команд.
  4. Регистры сегментов.

Есть 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»» «.

Для указания комментирования в языке ассемблер используется символ точка с запятой — «;». Допустимо использовать комментарии как в начале строк, так и после команды. Заканчивается комментарий переводом строки.

Директива эквивалентности используется схожим образом тому, как в других языках указывают константные выражения. Эквивалентность указывается следующим способом:

Таким образом в программе все вхождения <name> будут заменяться на <operand>, на месте которого допустимо указывать целое число, адрес, строку или другое имя. Директива EQU похожа по своей работе на #define в языке С++.

Директивы данных

Языки высокого уровня (C++, Pascal) являются типизированными. То есть, в них используются данные, имеющие определенный тип, имеются функции их обработки и т. д. В языке программирования ассемблер подобного нет. Существует всего 5 директив для определения данных:

  1. DB — Byte: выделить 1 байт под переменную.
  2. DW — Word: выделить 2 байта.
  3. DD — Double word: выделить 4 байта.
  4. DQ — Quad word: выделить 8 байтов.
  5. 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

Команды (инструкции)

Синтаксис команд ассемблера или инструкций ассемблера выглядит следующим образом:

<label>: <instruction operands> [;Comment]

Метка (label:) обязательно завершается двоеточием и может располагаться в отдельной строке. Метки используются для того, чтобы ссылаться на команды внутри программы.

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

В роли операндов команды могут выступать:

  • регистры, обращение к которым происходит по их именам;
  • константы;
  • адреса.
Читайте также:  Мышь клавиатура колонки микрофон одним словом

Подробнее об адресах

Адрес может передаваться несколькими способами:

  1. В виде имени переменной, которая в ассемблере является синонимом адреса.
  2. Если переменная является массивом, то обращение к элементу массива происходит через имя его переменной и смещения. Для этого существует 2 формы: [<имя> + <смещение>] и <имя>[<смещение>]. Следует учитывать, что смещение — это не индекс в массиве, а размер в байтах. Программисту самому необходимо понимать, на сколько нужно сделать смещение в байтах, чтобы получить нужный элемент массива.
  3. Можно использовать регистры. Для обращения к памяти, в которой хранится регистр, нужно использовать квадратные скобки: [ebx], [edi].
  4. [] — квадратные скобки допускают применение сложных выражений внутри себя для вычисления адреса: [esi + 2*eax].

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

Помимо этого, в ассемблер существуют сокращения: r — для регистров, m — для памяти и i — для операнда. Эти сокращения используются с числами 8, 16 и 32 для указания размера операнда: r8, m16, i32 и т. д.

add i8/i16/i32, m8/m16/m32 ;суммирование операнда с ячейкой памяти

Команда mov или пересылка

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

В процессоре существует и другие команды для реализации пересылки. Например, XCHG — команда обмена операндов значениями. Но с точки зрения программиста, все они реализованы через команду базовую MOV. Рассмотрим примеры:

MOV i, 0 ; Записать в i значение 0
MOV ECX, EBX ; Пересылка значения EBX в ECX

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

Инструментарий

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

  • Borland Turbo Assembler (TASM) — один из самых популярных инструментов. Хорошо подходит для разработки под DOS и плохо — под Windows.
  • Microsoft Macro Assembler (MASM) — это пакет для разработки на ассемблере в среде Windows. Существует как отдельно, так и в виде встроенной функции в среде Visual Studio. Ассемблер и языки высокого уровня часто совместимы. В том смысле, что последние могут использовать ассемблер напрямую. Например, С++.
  • Netwide Assembler (NASM) — популярный свободный ассемблер для архитектуры Intel.

Существует множество инструментов. При этом следует сделать особую пометку о том, что нет единого стандарта синтаксиса ассемблера. Есть 2 наиболее применимых: AT&T-синтаксис, ориентированный на процессоры производства не Intel, и, соответственно, Intel-синтаксис.

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

Язык ассемблер. Команды и основы ассемблера на News4Auto.ru.

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

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

Источник

Курсовая работа на тему Программирование на Ассемблере

Написать макрокоманду для выборки из некоторого массива слов со знаком всех элементов больших одного значения, но меньших другого. С помощью этой макрокоманды обработать два массива, выбирая из 1-го элементы большие 1000, но меньшие 2000, а из 2-го – большие (–5000), но меньшие 50000.

2 Разработка программы без интерфейса

2.1 Спецификация задачи

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

2.2 Организация данных

Для хранения исходных данных и результатов используются массивы:

ArrS1 dw 07CF EC77, EC79, 0000, 1387, 1389, 03E8, 05DC, 07D2, F830

Counter1 = ($ — offset ArrS1) / type ArrS1

ArrD1 dw ?, Counter1 dup (?) ;первый выходной массив

;второй выходной массив

ArrS1 dw 07CF, 03E9, 03E7, 07D1, FF9C, 05DC, 07DO

Counter2 = ($ — offset ArrS2) / type ArrS2

ArrD2 dw ?, counter2 dup (?) ;второй выходной массив

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

min1 = 1000 ;промежуток от 1000 до 2000

min2 = — 5000 ;промежуток от -5000 до 5000

Для передачи параметров в макрокоманду используются переменные:

x — входной массив

у — выходной массив

counter — количество чисел в массиве

min, max — промежуток для выборки,

2.3 Разработка алгоритмов

Алгоритм макроуровня представлен на рисунке 2.3.1.

Рисунок 2.3.1 – Алгоритм макроуровня

Алгоритм подпрограммы представлен на рисунке 2.3.2.

Рисунок 2.3.2 – Алгоритм макрокоманды

2.4 Текст программы

Name program ;Имя программы

min1 = 1000 ;промежуток от 1000 до 2000

min2 = -5000 ;промежуток от -5000 до 5000

Data Segment ;сегмент данных

ArrS1 dw 07CF EC77, EC79, 0000, 1387, 1389, 03E8, 05DC, 07D2, F830

;вычисление длины массива

Counter1 = ($ — offset ArrS1) / type ArrS1

ArrD1 dw ?, Counter1 dup (?) ;первый выходной массив

;второй выходной массив

ArrS1 dw 07CF, 03E9, 03E7, 07D1, FF9C, 05DC, 07DO

Counter2 = ($ — offset ArrS2) / type ArrS2

ArrD2 dw ?, counter2 dup (?) ;второй выходной массив

Code Segment ;сегмент кода

Assume CS:Code, DS:Data

;ArrS — входной массив

;ArrD — выходной массив

;counter — количество чисел в массиве

;min, max — промежуток для выборки,

abc Macro ArrS, ArrD, counter, min, max

LOCAL M1, M2 ;локализация меток

LEA SI, ArrS ;загрузка начальных

LEA DI, ArrD ;адресов

MOV CX, COUNTER ;загрузка счетчика циклов

ADD DI, type ArrS ;модификация адреса

XOR DX,DX ;обнуление счетчика выбранных элементов

M2: MOV AX, [SI] ;загрузка элемента

CMP AX, min ;сравнение с нижним интервалом

JLE M1 ;если число меньше, то переход по метке

CMP AX, max ;сравнение с верхним интервалом

JGE M1 ;если число больше, то переход по метке

MOV [DI], AX ;выбор элемента

INC DX ;инкремент выбранных элементов

ADD DI, type ArrD ;модификация адреса входного массива

M1: ADD SI, type ArrS ;модификация адреса входного массива

LOOP M2 ;зацикливание

MOV ArrD, DX ;запись элементов в выходной массив

MOV AX, Data ;инициализация сегментного регистра

abc ArrS1, ArrD1, Counter1, min1, max1 ;макровызов

abc ArrS2, ArrD2, Counter2, min2, max2 ;макровызов

3 Разработка программы с интерфейсом

3.1 Спецификация задачи

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

3.2 Организация данных

Для хранения исходных данных и результатов используются массивы:

IN_ARR1 DW 256 DUP (?) ;входные массивы

IN_ARR2 DW 256 DUP (?)

OUT_ARR1 DW 256 DUP (?) ;выходные массивы

OUT_ARR2 DW 256 DUP (?)

В задаче также были введены следующие вспомогательные переменные и константы:

STR_BUFF DB 255. 255 DUP (?) ;буфер ввода

COUNTER DW ? ;счетчики

MINUS DB ? флаг минуса

FERR DB ? ;флаг ошибки

Для вывода на экран были введены строковые константы:

MSG_INP_ARR1 DB ‘ENTER NUMBERS F IRST ARRAY : ‘

MSG_INP_ARR2 DB ENTER NUMBERS SE COND ARRAY: ‘

3.3 Разработка алгоритмов

Алгоритм макроуровня представлен на рисунке 3.3.1.

Рисунок 3.3.1 – Блок-схема алгоритма макроуровня

Алгоритм ввода и записи данных в память представлен на рисунке 3.3.2.

Рисунок 3.3.2 – Блок-схема алгоритмов ввода и записи данных в память

Алгоритм подпрограммы вывода на экран выходного массива представлен на рисунке 3.3.3.

Рисунок 3.3.3 – Блок-схема алгоритма вывода выходного массива

Алгоритм подпрограммы ввода количества элементов массива представлен на рисунке 3.3.4.

Алгоритм подпрограммы перевода введенной строки в число, для записи в массив, представлен на рисунке 3.3.5.

Алгоритм подпрограммы перевода числа в строку, для вывода на экран, представлен на рисунке 3.3.6.

3.4 Текст программы

MIN1 = 1000 ;интервал выборки от 1000 до 2000

MIN2 = — 5000 ;интервал выборки от -5000 до 5000

MSG_INP_ARR1 DB 10,13,’ENTER NUMBERS FIRST:’,10,13,’$ ‘

MSG_INP_ARR2 DB 10,13,’ENTER NUMBERS 2-ND ‘,10,13,’$’

MSG_EXT DB ‘PRESS ANY KEY TO EXIT !’,’$’

IN_ARR1 DW 256 DUP (?)

IN_ARR2 DW 256 DUP (?)

OUT_ARR1 DW 256 DUP (?)

OUT_ARR2 DW 256 DUP (?)

STR_BUFF DB 255. 255 DUP (?)

COUNTERX1 DW ? ;счетчик для X1

COUNTERX2 DW ? ;счетчик для X2

MINUS DW ? ;флаг минуса

FERR DB ? ;флаг ошибки

StkTop Label word

ASSUME CS: CODE, DS: DATA

;X -ВХОДНОЙ МАССИВ

;Y -ВЫХОДНОЙ МАССИВ

;N- СЧЕТЧИК ЗАПИЧАННЫХ ЧИСЕЛ

;MIN, MAX — ИНТЕРВАЛ ДЛЯ ВЫБОРКИ

;ВЫХОД: N-число чисел соответствующих условию

CHOICE MACRO X, Y, N, MIN, MAX

LOCAL M1, M2 ,EXTM

LEA SI, X ;загрузка начального адреса входного массива

MOV CX, [N] ;загрузка счетчика цикла

MOV N, 0 ;обнуление счетчика

LEA DI, Y ;загрузка начального адреса выходного массива

MOV AX, [SI] ;чтение элемента

CMP AX, MIN ;сравниваем с минимальной границей

JLE M1 ;если меньше то идем на М1

CMP AX, MAX ;сравниваем с максимальной границей

JGE M1 ;если больше идем на M1

MOV [DI], AX ;загрузка выбранного числа в выходной массив

INC N ;увеличить счетчик записанных чисел

ADD DI, TYPE Y ;модификация адреса выходного массива

ADD SI, TYPE X ;модификация адреса

LOOP M2 ;зацикливание

MOV AX, DATA ;инициализация

MOV DS, AX ;сегментного регистров

LEA DX, MSG_ARR1

MOV [COUNTERX1], AX ;поместить кол-во чисел в счетчик

CMP AX, 0 ;сравнить число с «0»

JE NEXT_ARRAY ;если введено «0» , переход

LEA DX, MSG_INP_ARR1 ;загрузка адреса сообщения

CALL PRINT_MSG ; приглашение к вводу в массив 1

LEA DI, IN_ARR1 ;загрузить адрес массива в DI

MOV CX, COUNTERX1 ;в CX поместить число элементов

LEA DX, MSG_X1 ;загрузить адрес сообщения

CALL INP_ARRAY ;вызвать процедуру ввода в массив

LEA DX, MSG_ARR2

CALL INP_COUNTER ;ввода числа элементов для ввода

MOV [COUNTERX2], AX ;поместить в переменную

CMP AX, 0 ;сравнить число с «0»

JE SEARCH ;пропустить ввод если введено 0

LEA DX, MSG_INP_ARR2 ;загрузка адреса сообщения

CALL PRINT_MSG ;вывести приглашение к вводу в 1

LEA DI, IN_ARR2 ;загрузить адрес массива в DI

MOV CX, COUNTERX2 ;в CX поместить число элементов

LEA DX, MSG_X2 ;загрузить адрес сообщения

CALL INP_ARRAY ;вызвать процедуру ввода в массив

;поиск чисел во входном массиве в заданных интервалах и запись в выходной массив

;вызов макрокоманды поиска чисел в заданных интервалах

CHOICE IN_ARR1, OUT_ARR1, COUNTERX1, MIN1, MAX1

CHOICE IN_ARR2, OUT_ARR2, COUNTERX2, MIN2, MAX2

;вывод выходного массива 1

Читайте также:  Пылесос для клавиатуры в Санкт Петербурге

LEA DX, MSG_ARR1 ;вывести сообщение

LEA DX, MSG_CARR ;вывести сообщение

LEA DX, MSG_Y1 ;загрузка адреса вывода сообщения

MOV CX, [COUNTERX1] ;число записанных чисел в выходном массиве

LEA SI, OUT_ARR1 ;адрес выходного массива

;вывод выходного массива 2

LEA DX, MSG_ARR2 ;вывести сообщение

LEA DX, MSG_CARR ;вывести сообщение

LEA DX, MSG_Y2 ;загрузка адреса вывода сообщения

MOV CX, [COUNTERX2] ;число записанных чисел в выходном массиве

LEA SI, OUT_ARR2 ;адрес выходного массива

CALL PRINT_MSG ;сообщение о выходе

INT 016h ;ожидать нажатие клавиши

INT 021h ;выход из программы

; Подпрограмма для вывода сообщений

; Подпрограмма для ввода строки

MOV AH, 0Ah ;функция ввода строки в буфер

; Подпрограмма для ввода ошибки ввода

LEA DX, MSG_ERR ;загрузить адрес сообщения

CALL PRINT_MSG ;вывести сообщение о ошибке

; Подпрограмма для вывода строки отсутствия элементов

LEA DX, MSG_NOT_ITEM ;загрузить адрес сообщения ошибкеи CALL PRINT_MSG ;вывести сообщение о ошибке

;Процедура ввода числа элементов в массиве

;ВЫХОД: AX — число

;цикл ввода числа элементов в массиве

LEA DX, MSG_CARR ;перенос каретки

LEA DX, MSG_COUNT ;вывести приглашение к вводу

LEA DX, STR_BUFF ;загрузка буфера ввода строки

CALL INPUT_STR ;ввод строки

LEA SI, STR_BUFF+2 ;загрузка адреса строки

CALL STR_TO_HEX ;вызвать процедуру преобразования

CMP FERR, 1 ;проверить флаг ошибки

JE MERR1 ;перейти на метку MERR

CMP AX, 255 ;сравнить AX с 255

JA MERR1 ;перейти по метке если больше

CALL PRINT_ERROR ;вывести сообщение о ошибке

JMP INP ;повтор ввода количества

;Процедура ввода чисел в массив

;ВХОД: DI — адрес массива для записи чисел

;CX — число элементов

;DX — адрес сообщения перед вводом

MOV COUNTER, 0 ;обнулить счетчик введенных чисел

;цикл ввода чисел в массив

CALL PRINT_MSG ;вывести на экран «X1[«

PUSH DI ;сохранить в стек адрес массива

LEA DI, STR_BUFF+2 ;загрузить адрес начала строки

MOV AX, [COUNTER] ;загрузка индекса

CALL HEX_TO_STR ;преобразовать счетчик ввода в строку

LEA DX, STR_BUFF+2

CALL PRINT_MSG ;вывести счетчик X1[ n

CALL PRINT_MSG ;закрыть индекс X1 [ n ]

POP DI ;восстановить из стека адрес

;ввод строки ,проверка корректности ввода, преобразование в число и запись в выходной массив

LEA DX, STR_BUFF ;загрузка адреса массива ввода

CALL INPUT_STR ;ввод строки

LEA SI, STR_BUFF+2 ;загрузка адреса строки

CALL STR_TO_HEX ;преобразование в число (выход AX= число)

CMP FERR, 1 ;проверка флага ошибки

JE MERR2 ;перейти на вывод ошибки если 1

MOV [DI], AX ;записать число в выходной массив

INC COUNTER ;увеличить счетчик чисел

ADD DI, 2 ;модификация адреса

LEA DX, MSG_CARR ;загрузка адреса переноса

CALL PRINT_MSG ;перенос на сл.строку

LOOP INP_ARR ;продолжать цикл пока cx!=0

JMP EXT_INP_ARRAY ;перейти на ввод кол-ва элементов сл.массива

CALL PRINT_ERROR ;вывести ошибку ввода

JMP INP_ARR ;перейти в начало цикла

;Процедура вывода чисел из массива на экран

;ВХОД: SI — адрес массива чисел

;CX — число элементов

;DX — адрес сообщения перед выводом

CMP CX, 0 ;число найденных элементов

JE NOT_ITEM1 ;если их нет, то перейти по метке NOT_ITEM1

MOV COUNTER, 0 ;обнулить счетчик выведенных чисел

;подготовка к выводу

CALL PRINT_MSG ;вывести Y1[

INC COUNTER ;+1 к счетчику чисел

LEA DI, STR_BUFF+2 ;адрес для преобразованной строки

MOV AX, [COUNTER] ;в AX число для преобразования

CALL HEX_TO_STR ;вызвать преобразование в строку

LEA DX, STR_BUFF+2

CALL PRINT_MSG ;вывести строку Y[ n

CALL PRINT_MSG ;закрыть индекс Y [ n ]

;преобразование числа выходного массива

LEA DI, STR_BUFF+2 ;адрес строки

MOV AX, [SI] ;поместить в AX

CALL HEX_TO_STR ;вызвать процедуру преобразования

ADD SI, 2 ;изменить адрес на сл.число

LEA DX, STR_BUFF+2

CALL PRINT_MSG ;вывести число

LEA DX, MSG_CARR

CALL PRINT_MSG ;перенос на сл.строку

LOOP OUTARR ;продолжать цикл пока cx!=0

CALL PRINT_ITEM ;отсутствия чисел в массиве

;Подпрограмма преобразование строки в число

;ВХОД: SI=адрес строки

PUSH CX ;сохранить счетчик цикла в стек

MOV FERR, 0 ;Обнуление

MOV MINUS, 0 ;флагов

MOV BX, 10 ;множитель

XOR AX, AX ;обнуление регистров

CMP BYTE PTR [SI], 13

JE INP_ERR ;если 1 символ «enter» ,перейти

JNE MNEXT1 ;если 1 символ не «-» ,перейти MOV MINUS, 1 ;установить флаг минуса

INC SI ;перейти к след символу строки

CMP BYTE PTR [SI], 13 ;если второй символ «enter»,

CMP BYTE PTR [SI], 13 ;Проверка конца строки

JE MNEXT2 ;если символ enter то перейти MNEXT2

JB INP_ERR ;если символ меньше 0, то ошибка

JA INP_ERR ;если символ больше 9, то ошибка

JMP NEXT_SYM ;иначе перейти по метке преобразования

MOV FERR, 1 ;установить флаг ошибки

JMP EXT_CONVERTED ;перейти на выход

MUL BX ;умножить AX на 10

SUB BYTE PTR [SI], ‘0’ ;отнять от символа 30h

MOV CL, BYTE PTR [SI] ;записать цифру в CL

ADD AX, CX ;прибавить цифру к общему числу

INC SI ;перейти к следующему символу строки

JMP MNEXT1 ;перейти на метку MNEXT1

CMP DX, 0 ;проверить был ли перенос при умножени

JNE MNEXT3 ;если dx не 0, то перейти к установке ошибки

JNE NOT_MINUS ;если положительное перейти по метке NOT_MINUS

CMP AX, 32768 ;сравнить с максимального отрицательным

JA MNEXT3 ;если больше, установить ошибку

NEG AX ;смена знака числа

JMP EXT_CONVERTED ;перейти к выходу из цикла преобразования

CMP AX, 32767 ;сравнить с максимальным

JBE EXT_CONVERTED ;если меньше или равно,

MOV FERR, 1 ;установка флага ошибки

POP CX ;восстановить из стека cx

;Подпрограмма преобразования числа в строку

;ВХОД : AX = число для преобразования

;ВЫХОД: DI = адрес начала строки для вывода

PUSH CX ; сохранить в стек счетчик

MOV BX, 10 ;делитель 10

TEST AX, 08000H ;проверить знак числа

MOV BYTE PTR [DI], ‘-‘ ;занести в строку —

NEG AX ;преобразовать в положительное

INC DI ;перейти к следюущему символу

XOR DX, DX ;остаток от деления в 0

DIV BX ;разделить число на 10

ADD DL, ‘0’ ;преобразовать остаток в символ

PUSH DX ;поместить символ в стек

INC CX ;увеличить счетчик символов +1

CMP AX, 0 ;если делимое еще не равно 0

JNE MNEXT4 ;продолжать деление

;записть символов в массив

POP DX ;достать из стека символ

MOV [DI], DL ;поместить в массив

INC DI ;изменить адрес на сл.ячейку

LOOP MNEXT5 ;продолжать цикл

MOV BYTE PTR [DI], ‘$’ ;записать в конце строки символ конца строки

POP CX ;восстановить CX

В данной работе разработана программа на языке Assembler, выбирающая из двух массивов слов со знаком элементы, входящие в заданный диапазон. Программа написана в двух вариантах: без интерфейса и с использованием интерфейса.

Список использованных источников

1 Комаров, В. М. Микропроцессорны е системы: Учебное пособие. – 2 изд., перераб. и доп. – Рыбинск: РГАТА, 2004. – 163 c.

2 Калашников, О. А. Ассемблер – это просто. Учимся программировать. – 2-е изд., перераб. и доп. – СПБ.: БХВ-Петербург, 2011. – 336 c.

Источник

Курсовая работа: Ассемблер 2

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

2. Содержание пояснительной записки:

1. Создание программы на ассемблере

2. Синтаксис ассемблера

3. Описание алгоритма

4. Описание программы

3. Дата выдачи задания:

4. Срок выполнения:

Задание выдал _______________Юрагов Е.А.

Задание принял _______________Тябенков А.О.

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

В то же время, внося в микропроцессор принципиальные изменения, разработчики были вы­нуждены постоянно иметь в виду необходимость обеспечения совмести­мости новых моделей со старыми, чтобы не отпугивать потенциального покупателя перспективой полной замены освоенного или разработанно­го им программного обеспечения. В результате современные микропро­цессоры типа Pentium, обеспечивая такие возможности, как 32-битную адресацию почти неограниченных объемов памяти, многозадачный ре­жим с одновременным выполнением нескольких программ, аппаратные средства защиты операционной системы и прикладных программ друг от друга, богатый набор дополнительных эффективных команд и способов адресации, в то же время могут работать (и часто работают) в режиме первых микропроцессоров типа 8086, используя всего лишь 1 мегабайт оперативной памяти, 16-разрядные операнды (т. е. числа в диапазоне до 2 16 -1=65535) и ограниченный состав команд. Поскольку программирова­ние на языке ассемблера напрямую затрагивает аппаратные возможности микропроцессора, прежде всего, следует выяснить, в какой степени про­граммист может использовать новые возможности микропроцессоров в своих программах, и какие проблемы программной несовместимости мо­гут при этом возникнуть.

Первые персональные компьютеры корпорации IBM, появившиеся в 1981 г. и получившие название IBM PC, использовали в качестве цент­рального вычислительного узла 16-разрядный микропроцессор с 8-раз­рядной внешней шиной Intel 8088. В дальнейшем в персональных компью­терах стал использоваться и другой вариант микропроцессора, 8086, ко­торый отличался от 8088 тем, что являлся полностью 16-разрядным. С тех пор его имя стало нарицательным, и в программах, использующих только возможности процессоров 8088 или 8086, говорят, что они работают в режиме 86-го процессора.

В 1983 г. корпорацией Intel был предложен микропроцессор 80286, в котором был реализован принципиально новый режим работы, получив­ший название защищенного. Однако процессор 80286 мог работать и в режиме 86-го процессора, который стали называть реальным.

В дальнейшем на смену процессору 80286 пришли модели 80386, i486 и, наконец, различные варианты процессора Pentium. Все они могут ра­ботать и в реальном, и в защищенном режимах. Хотя каждая следующая модель была значительно совершеннее предыдущей (в частности, почти на два порядка возросла скорость работы процессора, начиная с модели 80386 процессор стал 32-разрядным, а в процессорах Pentium реализован даже 64-разрядный обмен данными с системной шиной), однако с точки зрения программиста все эти процессоры весьма схожи. Основным их ка­чеством является наличие двух режимов работы — реального и защищен­ного. Строго говоря, в современных процессорах реализован еще и третий режим — виртуального 86-го процессора, или V86, однако в плане ис­пользования языка ассемблера этот режим не отличается от обычного режима 86-го процессора, и в этой книге мы его касаться не будем.

Реальный и защищенный режимы прежде всего принципиально раз­личаются способом обращения к оперативной памяти компьютера. Метод адресации памяти, используемый в реальном режиме, позволяет адресо­вать память лишь в пределах 1 Мбайт; в защищенном режиме использует­ся другой механизм (из-за чего, в частности, эти режимы и оказались полностью несовместимыми), позволяющий обращаться к памяти объе­мом до 4 Гбайт. Другое важное отличие защищенного режима заключается в аппаратной поддержке многозадачности с аппаратной же (т.е. реализо­ванной в самом микропроцессоре) защитой задач друг от друга.

Реальный и защищенный режимы имеют прямое отношение к работе операционной системы, установленной на компьютере.

В настоящее время на персональных компьютерах типа IBM PC ис­пользуются в основном два класса операционных систем (оба — разработ­ки корпорации Microsoft): однозадачная текстовая система MS-DOS и многозадачная графическая система Windows. Операционная система MS-DOS является системой реального режима; другими словами, она исполь­зует только средства процессора 8086, даже если она установлена на ком­пьютере с процессором Pentium. Система Windows — это система защи­щенного режима; она значительно более полно использует возможности современных процессоров, в частности, многозадачность и расширенное адресное пространство. Разумеется, система Windows не могла бы рабо­тать с процессором 8086, так как в нем не был реализован защищенный режим.

Читайте также:  Qwerty клавиатура с русскими буквами

Соответственно двум типам операционных систем, и все программ­ное обеспечение персональных компьютеров подразделяется на два клас­са: программы, предназначенные для работы под управлением MS-DOS (их часто называют приложениями DOS) и программы, предназначен­ные для системы Windows (приложения Windows). Естественно, приложе­ния. DOS могут работать только в реальном режиме, а приложения Windows — только в защищенном.

Таким образом, выражения «программирование в системе MS-DOS», «программирование в реальном режиме» и «программирование 86-го про­цессора» фактически являются синонимами. При этом следует подчерк­нуть, что хотя процессор 8086, как микросхема, уже давно не используется, его архитектура и система команд целиком вошли в современные про­цессоры. Лишь относительно небольшое число команд современных процессоров специально предназначены для организации защищенного режима и распознаются процессором, только когда он работает в защи­щенном режиме.

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

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

1. СОЗДАНИЕ ПРОГРАММЫ НА АССЕМБЛЕРЕ.

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

В большинстве случаев рекомендуется следую­щий процесс разработки программы на ассемблере:

1.Этап постановки и формулировки задачи:

· изучение предметной области и сбор материала в проблемно-ориентиро­ванном контексте;

· определение назначения программы, выработка требований к ней и пред­ставление требований, если возможно, в формализованном виде;

· формулирование требований к представлению исходных данных и вы­ходных результатов;

· определение структур входных и выходных данных;

· формирование ограничений и допущений на исходные и выходные дан­ные.

· формирование «ассемблерной» модели задачи;

· выбор метода реализации задачи;

· разработка алгоритма реализации задачи;

· разработка структуры программы в соответствии с выбранной моделью памяти.

3. Этап кодирования:

· уточнение структуры входных и выходных данных и определение ассемб­лерного формата их представления;

· комментирование текста программы и составление предварительного описания программы.

4. Этап отладки и тестирования:

· составление тестов для проверки правильности работы программы;

· обнаружение, локализация и устранение ошибок в программе, выявлен­ных в тестах;

· корректировка кода программы и ее описания.

5. Этап эксплуатации и сопровождения:

· настройка программы на конкретные условия использования;

· обучение пользователей работе с программой;

· организация сбора сведений о сбоях в работе программы, ошибках в выходных данных, пожеланиях по улучшению интерфейса и удобства рабе ты с программой;

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

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

Традиционно у существующих реализаций ассемблера нет интегрированной среды, подобной интегрированным средам Turbo Pascal, Turbo С или Visual C++. Поэтому для выполнения всех функций по вводу кода программы, ее трансляции, редактированию и отладке необходимо использовать отдельные служебные программы. Большая часть их входит в состав специализированных пакетов ассемблера.

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

Рис. 1. «Процесс разработки программы на ассемблере».

Программы, реализующие остальные шаги схемы, входят в состав программного пакета ассемблера. После написания текста программы на ассемблере наступает следующий этап — трансляция программы. На этом шаге формируется объектный модуль, который включает в себя представление исходной програм­мы в машинных кодах и некоторую другую информацию, необходимую для отладки и компоновки его с другими модулями. Традиционно на рынке ассемблеров для микропроцессоров фирмы Intel имеется два пакета: «Макроассемблер» MASM фирмы Microsoft и Turbo Assembler TASM фирмы Borland.

У этих пакетов много общего. Пакет макроассемблера фирмы Microsoft (MASM) получил свое название потому, что он позволял программисту зада­вать макроопределения (или макросы), представляющие собой именованные группы команд. Они обладали тем свойством, что их можно было вставлять в программу в любом месте, указав только имя группы в месте вставки. Пакет Turbo Assembler (TASM) интересен тем, что имеет два режима работы. Один из этих режимов, называемый MASM, поддерживает все основные возможнос­ти макроассемблера MASM. Другой режим, называемый IDEAL, предоставляет более удобный синтаксис написания программ, более эффективное использова­ние памяти при трансляции программы и другие новшества, приближающие компилятор ассемблера к компиляторам языков высокого уровня.

В эти пакеты входят трансляторы, компоновщики, отладчики и другие утили­ты для повышения эффективности процесса разработки программ на ассембле­ре.

В данной курсовой работе для получения объектного модуля исходный файл подвергается трансляции при помощи про­граммы tasm.exe из пакета TASM.

После устранения ошибок можно приступать к следующему шагу — созданию исполняемого (загрузочного) модуля, или, как еще называют этот процесс, к компоновке программы. Главная цель этого шага — преобразовать код и данные в объектных файлах в их перемещаемое выполняемое отображение. Процесс создания исполняемого модуля разделяют на 2 шага — трансляцию и компоновку. Это сделано намеренно для того, чтобы можно было объединять вместе несколько модулей (написанных на одном или нескольких языках). Формат объектного файла позволяет, при определенных условиях, объединить несколько отдельно оттранслированных исходных модулей в один модуль. При этом в функции компоновщика входит разрешение внешних ссылок (ссылок на процедуры и переменные) в этих модулях. Резуль­татом работы компоновщика является создание загрузочного файла с расширением ехе. После этого операционная система может загрузить такой файл и выполнить его.

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

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

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

Отладчики бывают двух типов:

· интегрированные — отладчик реализован в виде интегрированной среды типа среды для языков Turbo Pascal, Quick С и т.д.;

· автономные — отладчик представляет собой отдельную программу.

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

2. СИНТАКСИС АССЕМБЛЕРА

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

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

· идентификаторы — последовательности допустимых символов, использующиеся для обозначения таких объектов программы, как коды операций, имена переменных и названия меток. Правило записи идентификаторов заключается в следующем. Идентификатор может состоять из одного или нескольких символов. В качестве символов можно использовать буквы латинского алфавита, цифры и некоторые специальные знаки — _, ?, $, @.

· цепочки символов — последовательности символов, заключенные в одинарные или двойные кавычки;

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

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

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

Рассмотрим классификацию операндов, поддерживаемых транслятором ассемблера.

Постоянные или непосредственные операнды — число, строка, имя или вы­ражение, имеющие некоторое фиксированное значение. Имя не должно быть перемещаемым, то есть зависеть от адреса загрузки программы в па­мять.

Адресные операнды — задают физическое расположение операнда в памяти с помощью указания двух составляющих адреса: сегмента и смещений (рис. 2).

Рис. 2. «Синтаксис описания адресных операндов».

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

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

Базовый и индексный операнды . Этот тип операндов используется для реали­зации косвенной базовой, косвенной индексной адресации или их комбина­ций и расширений.

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

Арифметические операторы. К ним относятся унарные операторы «+» и «-», бинарные «+» и «-», операторы умножения «*», целочисленного деления «/», получения остатка от деления «mod». Эти операторы расположены на уровнях приоритета 6, 7, 8 в табл. 2.1.

Операторы сдвига выполняют сдвиг выражения на указанное количество раз­рядов.

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

Источник