Word ptr ассемблер что это

Группа директив для указания типа процессора

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

.186, .286, .386, .486, .586, .686 — использование инструкций процессоров 80186, 80286, 80386, 80486, Pentium, Pentium Pro

.286P, .386P, .486P, .586P, .686P — использование инструкций процессоров, включая инструкции защищенного режима

.287, .387 — использование инструкций математического сопроцессора

Пример кода:

	; по-умолчанию в начале ставится режим .8086
	.model small
	.stack 100h
	.code
	.486	; указываем режим 80486, чтобы иметь возможность использовать команду BSWAP
start:	mov	edx, 01020304h
	bswap	edx
	mov	ax, 4C00h
	int	21h
	end start

Директивы для указания сегментов

Директива SEGMENT

name SEGMENT [align] [combine] [use] [‘class’]

Определяет сегмент с заданным именем name. Если сегмент с таким именем уже был определен ранее, то данный сегмент интерпретируется как продолжение предыдущего.

Необязательные параметры:

align — определяет выравнивание начального адреса сегмента на границу, определяемую значением параметра. Возможные значения:

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

use — определяет разрядность сегмента. Возможные значения:

class — задает строковое значение «класса» сегмента. Компоновщик объединяет вместе в памяти все сегменты с одним и тем же именем класса.

Директива ENDS

ENDS

Определяет конец сегмента.

Директива ASSUME

ASSUME register:segment[,register:segment][, register:segment]…

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

Пример кода:

	.386

stack16	segment	stack
	db	100 dup(0)
	ends

data16	segment
var	db	0
	ends

code16	segment	use16 'code'
	assume	cs:code16, ds:data16, ss:stack16
start:
	mov	var,00h
	mov	ax,4C00h
	int	21h
	ends

	end	start

Директивы для упрощенного указания сегментов

Директива .MODEL

.MODEL memory-model [, language-type] [, stack-option]

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

Параметры:

memory-model — модель памяти. Возможные значения:

language-type — тип языка программирования. Возможные значения:

stack-option — организация стека. Возможные значения для 16 бит: NEARSTACK, FARSTACK. Для 32 бит не используется. Указание NEARSTACK группирует сегменты стека в один физический сегмент (DGROUP) вместе с данными. Регистр сегмента стека SS назначается на тот же адрес что и регистр сегмента данных DS. FARSTACK не группирует стек с сегментом данных DGROUP; таким образом регистр SS не будет равен регистру DS.

Директива .CODE или CODESEG

.CODE [имя]

Определяет начало сегмента кода. Если задали среднюю или большую модель памяти, то за  директивой может следовать необязательное имя, которое указывает имя сегмента. По-умолчанию имя сегмента _TEXT.

Директива .DATA или DATASEG

.DATA

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

Директива .DATA?

.DATA?

Определяет в модуле начало неинициализированного сегмента данных.

Директива .CONST

.CONST

Определяет начало сегмента данных-констант.

Сегменты .DATA, .DATA?, .CONST помещаются в одну группу с именем DGROUP

Директива .STACK или STACK

.STACK [размер]

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

Пример кода:

        .model small,stdcall
        .stack  100h
        .data
str     db      'Hello, world!',0
        .code
start:  mov     ax,4C00h
        int     21h
        end start

Группа директив для резервирования памяти

DB, DW, DD, DF, DP, DQ, DT — Резервирование памяти с размером соответственно 1 байт (DB), 2 байта (DW), 4 байта (DD), 6 байт (DF, DP), 8 байт (DQ) и 10 байт (DT)

[имя] DB выражение[, выражение][, выражение]…

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

счетчик DUP (выражение[, выражение]…)

Повторяет операцию выделения памяти для указанных данных столько раз, сколько задано значением счетчика

Пример кода:

val1	dw	?
val2	db	10 dup(0)
val3	dd	4 dub(0FFFFFFFFh)
val4	db	'Test string',0
val5	db	2 dup(0Fh), 4 dup(?)

Директива STRUC (STRUCT)

[имя] STRUC

Определяет структуру данных с заданным именем, содержащую поля. В каждом поле для определения его размера используются обычные директивы выделения данных (DB,  DW и т.д.). Поля структуры могут быть именованными или нет.

Директива ENDS

[имя] ENDS

Определяет конец структуры.

Пример кода:

str1	struc
	db	10h
field1	dw	?
field2	db	5 dup(?)
str1	ends

Директива UNION

[имя] UNION

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

Пример кода:

str1	union
	db	?
	db	?
	db	2 dup(0)
str1	ends

str2	union
	dw	?
	dw	?
str2	ends

Группа директив модификации размера указателей

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

BYTE [PTR] — Приводит адресное выражение к размеру в байт

DWORD [PTR] — Приводит адресное выражение к размеру в двойное слово (4 байта)

FAR [PTR] — Приводит к тому, что адресное выражение будет дальним указателем

FWORD [PTR] — Приводит к тому, что адресное выражение будет иметь размер 32-разрядного дальнего указателя

NEAR [PTR] — Приводит к тому, что адресное выражение будет ближним указателем на код

PWORD [PTR] — Приводит к тому, что адресное выражение будет иметь размер 32-разрядного дальнего указателя

QWORD [PTR] — Приводит к тому, что адресное выражение будет иметь размер четверного слова (8 байт)

SHORT — Приводит к тому, что выражение будет указателем на код короткого типа (в границах -128 до +127 байт от текущего адреса программы)

TBYTE [PTR] — Приводит к тому, что адресное выражение будет иметь размер 10 байт

WORD [PTR] — Приводит адресное выражение к размеру в слово (2 байта)

Пример кода:

	mov	es:[di], dword ptr 0

Директивы определения процедур

Директива PROC

имя PROC [язык] [расстояние] [, аргумент] [, аргумент] …

Определяет начало процедуры с указанным именем.

Необязательные параметры:

язык — определяет, из какого языка выполняется вызов для доступа к данной процедуре: C, PASCAL, BASIC, STDCALL или NOLANGUAGE. Этим определяются соглашения по именам идентификаторов, порядок аргументов в стеке и то, останутся ли аргументы в стеке при возврате управления из процедуры (см. директиву MODEL). Если язык не задан, то используется язык заданный в директиве MODEL.

расстояние — это значения NEAR или FAR. Оно определяет тип инструкций RET или RETF, которые будут использоваться в процедуре.

аргумент — параметр процедуры в формате имя[:тип], где имя — имя параметра, тип — тип параметра. В качестве параметра можно задать массив в виде имя[N]:тип. Параметры будут доступны в процедуре через положительные смещения относительно регистра BP. Компилятор автоматически преобразует обращения к параметру по имени в соответствующие смещения относительно BP.

Директива ENDP

[имя] ENDP

Определяет окончание процедуры

Директива USES

USES элемент[, элемент]…

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

Директива LOCAL

LOCAL элемент[, элемент]…[=идентификатор]

В процедуре директива LOCAL определяет имена,  которые доступны в стеке через отрицательные смещения относительно регистра BP. Если указан идентификатор, то ему присваивается количество байт, выделенных на локальные переменные (размер всего блока локальных переменных в байтах).

Пример кода:

        .386
        .model  small, stdcall
        .stack  100h
        .code
test    proc    Param1:word, Param2[3]:word
        uses    ax, bx
        local   LocVar:word = @size
        mov     ax, @size
        mov     ax, LocVar
        mov     ax, Param1
        mov     ax, Param2[2]
        ret
test    endp

start:  mov     ax, 4C00h
        int     21h

        end start

Директивы для макроопределений

Директива MACRO

имя MACRO [параметр][, параметр]…

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

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

Пример кода:

        .386
        .model  small, stdcall
        .stack  100h
        .data
var     dw      0
        .code
MAddr   macro	sreg,reg,addr
        mov     reg, seg addr
        mov     sreg,reg
        mov     reg, offset addr
        endm

start:  MAddr	ds,di,var
        mov     ax, 4C00h
        int     21h

        end start

Директива ENDM

ENDM

Определяет окончание макроопределения

Директива REPT

REPT выражение

Повторяет блок операторов, заданный между директивами REPT и ENDM столько раз, сколько задается выражением. Блок операторов должен заканчиваться директивой ENDM.

Директива IRP

IRP параметр, аргумент[. аргумент]…

Повторяет блок операторов, заданный между директивой IRP и ENDM со строковой подстановкой. Аргументами может быть любой текст: символы, строки, числа и т.д. Для каждого указанного аргумента ассемблирование блока операторов выполняется только один раз. При каждом ассемблировании блока для каждого вхождения «параметра» в операторах подставляется следующий аргумент в списке.

Пример кода:

	irp	reg,ax,bx
	push	reg
	endm
	; после ассемблирования получится следующий код
	push	ax
	push	bx

Другие директивы

Директива COMMENT

COMMENT [символ ограничитель] … [символ ограничитель]

Позволяет задать многострочный комментарий, ограниченный с начала и с конца заданным символом-ограничителем.

Пример кода:

comment *
  Несколько
  строк
  комментария
*

Директива EQU

имя EQU выражение

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

Пример кода:

var	equ	4000h
mov	ax, var	; то же самое, что mov ax,4000h

Директива END

END метка

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

Директива EVEN

EVEN

Округляет счетчик адреса до следующего четного адреса

Директива SEG

SEG выражение

Возвращается адрес сегмента выражения со ссылкой на память

Директива OFFSET

OFFSET выражение

Возвращает смещение выражения в текущем сегменте (или в группе, которой принадлежит сегмент, если используются упрощенные директивы определения сегментов).

Директива ORG

ORG выражение

Устанавливает счетчик инструкций в текущем сегменте в соответствии с адресом, задаваемым выражением.

Директива RADIX

RADIX основание

Задает основание системы счисления для целочисленных констант (2, 8, 10 или 16)

Директива SIZE

SIZE имя

Возвращает размер элемента данных, выделенного для переменной

Пример кода:

	.data
var	dw	4 dup(0)
	.code
	mov	ax,size var	;ax = 8

Оглавление

                         Выбор размера данных
-----------------------------------------------------------------

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

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

          .
          .
          .
          mov   al,1             ; байт
          mov   dx,si            ; слово
          mov   bx,[dl]          ; слово
          mov   [bp+si+2],al     ; байт
          .
          .
          .

     Аналогично, именованные ячейки памяти имеют заданные  разме-
ры,  поэтому  размер данных в следующих инструкциях для Турбо Ас-
семблера ясен:

          .
          .
          .
          .DATA
 TestChar           DB   ?
 TempPointer        DW   TestChar
          .
          .
          .
          .CODE
          .
          .
          .
          mov   [TestChar],'A'
          mov   [TempPointer],0
          .
          .
          .

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

         mov   [bx],1

     Фактически, Турбо Ассемблер не будет знать, как такую  инст-
рукцию нужно ассемблировать.  Было бы  удобно  иметь  возможность
временного доступа к переменой размером в слово,  как к байту,  и
наоборот.

     Турбо Ассемблер дает вам способ гибкого определения  размера
данных  в  виде  операций  WORD PTR и BYTE PTR. Операция WORD PTR
указывает Турбо Ассемблеру, что данный операнд в памяти нужно ин-
терпретировать, как операнд размером в слово, а операция BYTE PTR
указывает Турбо Ассемблеру, что данный операнд в памяти нужно ин-
терпретировать,  как  операнд  размером в байт, независимо от его
предопределенного размера. Например, можно  сделать  так,  что  в
последнем  примере значение 1 размером в слово будет записываться
в слово, на которое указывает регистр BX:

         mov   WORD PTR  [bx],1

или же можно сделать так, что в данном примере значение 1  разме-
ром  в  байт  будет записываться в байт, на который указывает ре-
гистр BX:

         mov   BYTE PTR  [bx],1

     Заметим, что операции WORD PTR и BYTE PTR, если их применять
к  регистрам, не имеют смысла, так как регистры всегда имеют фик-
сированный размер. В таком случае операции BYTE PTR  и  WORD  PTR
игнорируются.  Аналогично, эти операции игнорируются при примене-
нии к константам, поскольку они всегда имеют тот же размер, что и
операнд-приемник.

     Операции WORD PTR и BYTE PTR  имеют  другое  назначение:  их
можно  использовать для временного выбора размера данных для име-
нованной  переменной  в  памяти.  Почему  это   может   оказаться
полезным? Рассмотрим следующий пример:

          .
          .
          .
          .DATA
 Source1  DD    12345h
 Source2  DD    54321h
 Sum      DD    ?
          .
          .
          .
          .CODE
          .
          .
          .
          mov   ax,WORD PTR [Source1]      ; получить младшее
                                           ; слово Source1
          mov   dx,WORD PTR [Source1+2]    ; получить старшее
                                           ; слово Source1
          add   ax,WORD PTR [Source2]      ; прибавить к Source2
                                           ; младшее слово
          adc   dx,WORD PTR [Source2+2]    ; прибавить к Source2
                                           ; старшее слово
          mov   WORD PTR [Sum],ax          ; сохранить младшее
                                           ; слово суммы
          mov   WORD PTR [Sum+2],dx        ; сохранить старшее
                                           ; слово суммы
          .
          .
          .

     Все переменные,   которые  используются  в  данном  примере,
представляют собой длинные целые или двойные слова.  Однако, про-
цессор  8086  не может выполнять сложение двойных слов непосредс-
твенно, поэтому такое сложение приходится разбивать на ряд опера-
ций  со словами.  Операция WORD PTR позволяет обращаться к частям
переменных Source1,  Source2 и Sum,  как к словам,  хотя сами эти
переменные представляют собой двойные слова.

     Операции FAR PTR и NEAR PTR хотя и не влияют непосредственно
на  размер  данных, они аналогичны операциям WORD PTR и BYTE PTR.
Операция FAR PTR приводит к тому, что  целевая  метка  инструкции
перехода  или вызова будет интерпретироваться, как дальняя метка,
и при этом будут загружаться оба регистра CS и IP. С другой  сто-
роны,  операция NEAR PTR вынуждает интерпретировать соответствую-
щую метку, как метку ближнего типа,  переход  на  которую  осуще-
ствляется путем загрузки одного регистра IP.


                     Данные со знаком и без знака
-----------------------------------------------------------------

     И числа со знаком, и беззнаковые числа состоят из последова-
тельности двоичных цифр.  Ответственность за различие  этих  двух
видов чисел возлагается на программиста,  который пишет программу
на Ассемблере (то есть на вас), а не на процессор 8086. Например,
значение 0FFFFh может представлять собой либо 65535,  либо -1,  в
зависимости от  того,  как  ваша  программа  его  интерпретирует.
Откуда вы знаете, что 0FFFFh - это -1? Прибавьте к нему 1:

        .
        .
        .
        mov     ax,0ffffh
        add     ax,1
        .
        .
        .

и вы обнаружите,  что результат будет равен 0.  Как раз такой ре-
зультат должен получиться при сложении -1 и 1.

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

        .
        .
        .
        mov     ax,offffh
        sub     ax,1
        .
        .
        .

     Результат при этом был бы равен 0FFFEh, что представляет со-
бой 65534 (беззнаковое число) или -2 (число со знаком).

     Если это кажется непонятным,  прочитайте одну из книг, реко-
мендуемых  в  конце  данного руководства (или одну из книг по Ас-
семблеру,  изданных в СССР,  например книгу Бредли). Это позволит
вам больше узнать об арифметике с дополнением до двух - средстве,
с помощью которого процессор 8086 обрабатывает числа со знаком. К
сожалению, мы не располагаем здесь местом, чтобы подробно расска-
зать об арифметике значений со знаком,  хотя для программиста это
представляет собой одну из важных тем, которую нужно хорошо пони-
мать. Пока же запомните, что инструкции ADD, SUB, ADC и SBB рабо-
тают  одинаково  хорошо  как с беззнаковыми значениями,  так и со
значениями со знаком,  поэтому для таких  операций  не  требуется
специальных инструкций сложения или сочетания.  Знак имеет значе-
ние в операциях умножения или деления (как вы увидите  далее),  а
также при преобразовании размеров данных.




TASM2 #1-5/Док              = 204 =

Оглавление

Введение в Ассемблер. Работа с регистрами. Адресация и команды пересылки данных. Арифметические операции с целыми числами

Адресация и выделение памяти

/* использование косвенной адресации */
/* подключаемые заголовочные файлы */
#include <stdio.h> // необходим для работы printf
#include <conio.h> // необходим для работы _getch();
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
 
/* глобальные переменные */
BYTE  a=10; // 8-битное беззнаковое целое число
DWORD addressRet; // переменная для хранения адреса
 
/* главная функция */
void main()
{
	__asm {
		LEA EAX, a;	// загрузка эффективного адреса переменной a в регистр EAX
		            // (в 32-разрядной ОС адрес ячейки памяти занимает 4 байта,
		            // поэтому для хранения адреса надо использовать расширенные
		            // регистры)
 
		MOV addressRet, EAX; // помещаем в переменную addressRet адрес переменной
		                     // а, хранящийся в регистре EAX. Обратите внимание:
		                     // этот адрес меняется при каждом запуске программы
 
		MOV BYTE PTR [EAX], 100; // помещаем по адресу, хранящемуся в регистре EAX
		                        // число 100 - фактически, присваиваем переменной а
		                        // значение  100
	};
	printf("address of variable a is %un", addressRet); // выводим адрес переменной a
	printf("value of variable a = %un", a); // выводим значение переменной а
	_getch();
}

LEA EAX, c;
MOV BYTE PTR [EAX], 70000;

/* использование косвенной адресации */
#include <stdio.h> // необходим для работы printf
#include <conio.h> // необходим для работы _getch();
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
BYTE ar[6] = {1, 12, 128, 50, 200, 10}; // статический массив типа BYTE
BYTE  a1, a2, a3, a4, a5; // 8-битные беззнаковые числа
WORD  b1, b2;             // 16-битные беззнаковые числа
DWORD c;                  // 32-битное беззнаковое число
 
void main()
{
	__asm {
		LEA EBX, ar; // загрузка эффективного адреса первого элемента массива
		             // ar в регистр EAX
		MOV AL, BYTE PTR [EBX]; // помещаем в регистр AL число (типа BYTE)
		                        // число, записанное по адресу, хранящемуся
		                        // в регистре EBX, то есть первый элемент массива
		MOV a1, AL; // записываем содержимое регистра AL в переменную a
 
		/*помещаем в переменную a2 число, записанное по адресу "начало массива 
		плюс 1 байт", то есть по адресу второго элемента массива*/
		MOV AL, BYTE PTR [EBX] + 1;
		MOV a2, AL;
		/*помещаем в переменную a3 число, записанное по адресу "число, записанное в
		регистре EBX плюс 1", то есть по адресу второго элемента массива*/
		MOV AL, BYTE PTR [EBX+1] ;
		MOV a3, AL;
		/*помещаем в переменную a4 число, записанное по адресу "номер,
		хранящийся в регистре EDX, начиная с номера, записанного регистре EBX",
		то есть второй элемент массива*/
		MOV EDX, 1;
		MOV AL, BYTE PTR [EBX][EDX];
		MOV a4, AL;
		/*помещаем в переменную a5 число, записанное по адресу "сумма чисел,
		записанных в регистрах EBX и EDX", то есть второй элемент массива*/
		MOV AL, BYTE PTR [EBX+EDX];
		MOV a5, AL;
		/*помещаем в переменную b1 2 и 1 элементы массива*/
		MOV AX, WORD PTR [EBX];
		MOV b1, AX;
		/*помещаем в переменную b2 4 и 3 элементы массива*/
		MOV AX, WORD PTR [EBX]+2;
		MOV b2, AX;
		/*помещаем в переменную с 6, 5, 4 и 3 элементы массива*/
		MOV EAX, DWORD PTR [EBX]+2;
		MOV c, EAX;
 
	};
 
	printf("first element of array a1 = %u n", a1);
	printf("second element of array a2 = %u n", a2);
	printf("second element of array (another way) a3 = %u n", a3);
	printf("second element of array (base addressation) a4 = %u n", a4);
	printf("second element of array (base addr. - another way) a5 = %u n", a5);
	printf("1, 2 elements of array  b1 = %u n", b1);
	printf("3, 4 elements of array  b2 = %u n", b2); 
	printf("3, 4, 5, 6 elements of array  c = %u n", c);
	_getch();
}

<тип переменной> * <имя указателя>

/* получение адреса переменной - сравнение С и Assembler */
#include <stdio.h> // необходим для работы printf
#include <conio.h> // необходим для работы _getch();
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
 
BYTE a=10;
BYTE *cAddr;
DWORD asmAddr;
BYTE b;
 
void main()
{
 
	__asm {
		LEA EBX, a;      // загрузка эффективного адреса переменной a в регистр EBX
		MOV asmAddr, EBX; // помещаем в переменную asmAddr содержимое регистра EBX,
		                  // т.е. адрес переменной a
	};
 
	cAddr=&a; // записываем в переменную типа BYTE* адрес переменной типа BYTE
	b=*cAddr; // осуществляем разыменование указателя на переменную а
 
	printf("Assembler: address of a is %un", asmAddr);
	printf("C: address of a is %un", cAddr);
	printf("C: value of a is %un", b);
	_getch();
}

/* адресация в массивах */
#include <stdio.h> // необходим для работы printf
#include <conio.h> // необходим для работы _getch();
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
 
unsigned int mas[4]; // массив 4-байтовых целых чисел
unsigned int *ptrMas; // указатель на переменную типа unsigned int
unsigned short int masShort[4]; // массив 2-байтовых целых чисел
unsigned short int *ptrMasShort; // указатель на переменную типа unsigned short int
BYTE masBYTE[4]; // массив 1-байтовых целых чисел
BYTE *ptrMasBYTE; // указатель на переменную типа BYTE
 
void main()
{
	ptrMas = mas; // помещаем в указатель адрес первого элемента массива
	ptrMasShort = masShort;
	ptrMasBYTE = masBYTE;
 
	printf("array of int n");
	for(int i=0; i<4; i++)
		printf("int pointer+%u = %un", i, ptrMas+i);
 
	printf("narray of short int n");
	for(int i=0; i<4; i++)
		printf("short pointer+%u = %un", i, ptrMasShort+i);
 
	printf("narray of BYTE n");
	for(int i=0; i<4; i++)
		printf("byte pointer+%u = %un", i, ptrMasBYTE+i);
	_getch();
}

/* динамическое выделение памяти */
#include <stdio.h> // необходим для работы printf
#include <conio.h> // необходим для работы _getch()
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD
#include <stdlib.h> // необходим для работы malloc()
#include <malloc.h> // необходим для работы malloc()
 
void main()
{
    int* ptint; // указатель на переменную типа int 
/* Выделяем память под массив. Аргумент функции malloc() - число байт.
Нам нужен массив из 10 целых чисел. Поэтому общее число байт - размер числа
типа int (определяется функцией sizeof()), умноженный на число элементов массива.
Стоящая перед malloc() конструкция (int*) осуществляет приведение к типу int* 
(то есть теперь выделенная память будет рассматриваться компилятором как
совокупность 4 байтных ячеек, в которых хранятся числа типа int) */
    ptint = (int*)malloc(10 * sizeof(int));
	/* заполняем массив */
	for(int i=0; i<10; i++)
		ptint[i]=i;
	/*выводим элементы массива*/
	for(int i=0; i<10; i++)
		printf("%d ",ptint[i]);
free(ptint); // освобождаем память
	_getch();
}

Арифметические операции над целыми числами

Сложение и вычитание целых чисел

/* сложение целых чисел */
#include <stdio.h> // необходим для работы printf()
#include <conio.h> // необходим для работы _getch()
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
int a,b,c; DWORD d,e,f,m,n,l,k;
void main()
{
	a=100; b=-200; f=0;
	d=0xffffffff;	e=0x00000010;
	m=0x12345678; n=0xeeeeeeee; l=0x11111111; k=0x22222222;
	__asm{
       /* сложение положительного и отрицательного чисел */
		MOV EAX, a;
		ADD EAX, b;
		MOV c, EAX;
	/* сложение двух больших чисел */
		MOV EAX, e; // EAX = 0x00000010
		ADD d, EAX; // результат превышает 4 байта, поэтому флаг CF
		            // устанавливается в 1:
		          //   0xffffffff
		          // + 0x00000010
		          //   ----------
		          //   0x0000000f (и 1 должна переноситься в следующий разряд,
		          //   но его нет, поэтому устанавливается флаг CF)
		ADC f, 0; // осуществляет сложение двух операндов (подобно команде ADD) и 
		          // флага (бита) переноса CF. Вначале f=0, второй операнд также 0,
		 // поэтому в данном случае выполнение команды сводится к помещению в
		        // переменную f значения CF
	/* сложение двух больших чисел, расположенных в паре регистров */
		MOV EDX, m; // поместили в EDX старшие 4 байта первого числа,
                         //EDX=0x12345678
		MOV EAX, n; // поместили в EAX младшие 4 байта первого числа,
                         // EAX=0xeeeeeeee
		MOV ECX, l; // поместили в ECX старшие 4 байта второго числа,
                         // ECX=0x11111111
		MOV EBX, k; // поместили в EBX младшие 4 байта первого числа,
                         // EBX=0x22222222
		ADD EAX, EBX; // сложили младшие 4 байта
		MOV n, EAX;
		ADC EDX, ECX; // сложили старшие 4 байта
		MOV m, EDX;
	};
	printf("c=a+b=%dn",c);
	printf("f=d+e=%x%xn",f,d);
	printf("sum of lowest 4 bytes = %xn",n);
	printf("sum of highest 4 bytes = %xn",m);
    _getch();
}

/*вычитание целых чисел*/
#include <stdio.h> // необходим для работы printf()
#include <conio.h> // необходим для работы _getch()
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
int a,b,c;
__int64 i,j,k;   
void main()
{
	a=100; b=-200;
	i=0x1ffffffff;
	j=0x1fffffffb;
	__asm{
        /* вычитание 32-битных чисел */
		MOV EAX, a;
		SUB EAX, b;
		MOV c, EAX;
		/* вычитание 64-битных чисел */
		MOV EAX, DWORD PTR i; // поместили в EAX адрес младших 4 байт числа i.
		                      // По этому адресу записано число 0xffffffff
		MOV EDX, DWORD PTR i+4; // поместили в EDX адрес старших 4 байт числа i.
		                      // По этому адресу записано число 0x00000001
		MOV EBX, DWORD PTR j; // поместили в EBX адрес младших 4 байт числа j.
		                      // По этому адресу записано число 0xfffffffb
		MOV ECX, DWORD PTR j+4; // поместили в ECX адрес старших 4 байт числа j.
		                      // По этому адресу записано число 0x00000001
		SUB EAX, EBX; // вычитаем из младших 4 байт числа i младшие 4 байта
		              // числа j. Эта операция влияет на флаг CF
		SBB EDX, ECX; // вычитаем из старших 4 байт числа i старшие 4 байта 
		              // числа j, а также флаг CF
		MOV DWORD PTR k, EAX; // помещаем в память младшие 4 байта результата
		MOV DWORD PTR k+4, EDX; // помещаем в память старшие 4 байта результата
	};
	printf("c=a+b=%dn",c);
	printf("k=i-j=%I64xn",k);// интерпретируем выводимое число как __int64
    _getch();
}

Умножение целых чисел

IMUL operand1, operand2

IMUL operand1, operand2, operand3

#include <stdio.h> // необходим для работы printf()
#include <conio.h> // необходим для работы _getch()
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
DWORD a=100000; __int64 b;
int c=-1000; int e;
void main()
{
	__asm{
       /* беззнаковое умножение */
		MOV EAX, 100000; // поместили в EAX число, превышающее 2 байта
		MUL DWORD PTR a; // умножаем содержимое регистра EAX на a,
		                 // результат будет помещен в пару регистров
		                 // EDX:EAX
		MOV DWORD PTR b, EAX; // помещаем в младшие 4 байта
		                      // 8-байтной переменной b младшие 4 байта результата
		MOV DWORD PTR b+4, EDX; // помещаем в старшие 4 байта 
		                      // 8-байтной переменной b старшие 4 байта результата	   
	/* знаковое умножение */
		IMUL EAX, c, 1000; // умножаем с на 1000 и результат помещаем в EAX
		MOV e, EAX; // помещаем результат умножения в переменную e
	};
	printf("a*100000 = %I64dn",b);// интерпретируем выводимое число как __int64
	printf("e = %dn",e);
    _getch();
}

Деление целых чисел

#include <stdio.h> // необходим для работы printf()
#include <conio.h> // необходим для работы _getch()
#include <windows.h> // содержит определение типов BYTE, WORD, DWORD;
DWORD a,b,c;
void main()
{
	a=100000; // делимое -  4 байта
	__asm{
        /* беззнаковое деление */
		MOV EAX, a; // поместили младшие 4 байта делимого в регистр EAX  
		MOV EDX, 0; // поместили старшие 4 байта делимого в регистр EDX  
		MOV EBX, 30; // поместили в EBX делитель (4 байта!)
		DIV EBX; // выполнили деление содержимого EDX:EAX на
		         // содержимое EBX
		MOV b, EAX; // помещаем в b частное
		MOV c, EDX; // помещаем в c остаток
	};
	printf("div b = %dn",b);
	printf("mod c = %dn",c);
    _getch();
}

Литература

Команда
MOV пересылает содержимое источника
(второго операнда) на место приёмника
(первого операнда) (табл. 5.10). Флаги
команда не изменяет. Пересылаемая
величина извлекается из команды, регистра
или ячейки памяти, а записывается в
регистр или ячейку памяти. Пересылать
одной командой двойное слово запрещено.

Инструкции
с кодами операций 8C и 8E обеспечивают
загрузку и извлечение информации из
сегментных регистров. Занесение
информации в регистр CS запрещено, т.к.
регистровая пара CS:IP определяет адрес
команды, которая должна быть выполнена
следующей. Поэтому для этой цели
необходимо использовать любую инструкцию
дальнего (межсегментного) перехода (см.
раздел 5.5).

Табл. 10. КомандаMOV.

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

Например,
записать число 100 в сегментный регистр
DS можно так:

MOV АХ, 100

MOV DS, AX

Как
правило, в команде MOV легко определить
тип одного из операндов и размер
пересылаемой величины, например:

MOV АХ, 300 ;
пересылка слова

MOV AH, AL ;
пересылка байта

В ряде
случаев по операндам команды MOV нельзя
определить размер пересылаемой величины.
Пусть в регистре AX находится адрес
некоторой ячейки памяти и требуется
записать 0 в эту ячейку. Такое обнуление
можно сделать с помощью команды:

MOV [AX], 0

Однако
по этой команде нельзя определить,
какого размера пересылаемый ноль,
поскольку второй операнд может обозначать
ноль размером в байт (00h) или размером в
слово (0000h). Кроме того, адрес из регистра
AX может быть также адресом ячейки как
размером в байт, так и размером в слово
(с одного и того же адреса могут начинаться
ячейки разных размеров). Поэтому ассемблер
зафиксирует ошибку, сообщая, что типы
операндов неизвестны.

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

<тип> PTR
<выражение>

где <тип> – BYTE, WORD
или DWORD, выражение может быть константным
или адресным.

Если
указано константное выражение, то
оператор сообщает, что значение выражения
(число) должно рассматриваться как
величина указанного типа (размера);
например, BYTE PTR 0 – ноль как байт, а WORD
PTR 0 – ноль как слово.

Если в
PTR указано адресное выражение, то оператор
сообщает, что адрес, являющийся значением
выражения, должен восприниматься
ассемблером как адрес ячейки указанного
типа, например: WORD PTR A – адрес A обозначает
слово (байты с адресами A и A+1).

Вернемся
к нашему примеру и запишем его корректно
с использованием оператора PTR. При
обнулении байта по адресу из регистра
AX, то команда имеет вид:

MOV
BYTE PTR [AX], 0 или MOV [AX], BYTE PTR
0

Если
требуется переслать нулевое слово:

MOV
WORD PTR [AX], 0 или MOV [AX], WORD PTR
0

Обычно
принято уточнять тип операнда-адреса,
а не тип непосредственного операнда.

Перестановку
двух величин можно реализовать с помощью
команды MOV, однако существует и специальная
команда XCHG (табл. 11). Инструкция меняет
местами содержимое своих операндов.
Флаги команда не меняет.

Табл. 11. Команда
XCHG.

Например,
для обмена содержимого регистров AX и
BX следует записать:

MOV АХ, 124

MOV BX, 43

ХСHG AX, BX ;
АХ=43, BX=124

Перестановка
содержимого двух ячеек памяти недопустима.
Если требуется провести такую перестановку,
она реализуется через регистр. Следующий
пример меняет местами значения байтовых
переменных X и Y:

MOV AL, X ; AL=X

XCHG AL, Y ; AL=Y, Y=X

MOV X, AL ; X=Y
(исходное значение)

Рассмотрим
еще несколько примеров команды MOV:

A DW 10 DUP(0) ;
одномерный массив A из 10-ти элементов
размером слово

B DW A ; в
переменной B хранится адрес переменной
A

…

MOV BX, B ;
помещение в регистр BX адреса 1-ого
элемента

MOV DX, [BX] ;
помещение в регистр DX значения переменной
A

MOV AX, BX ;
помещение в регистр AX адреса 1-ого
элемента A

…

MOV BX, 4 ; индекс
второго элемента массива

MOV DX, A[BX] ;
модификация адреса по регистру BX

Модификация
адреса может быть выполнена и для
двумерного массива. Например, для матрицы
10×10:

A DW 10 DUP(10 DUP
(0))

запись элемента [i,j] в
регистр AX будет следующей (регистры SI
и DI содержат индексы):

MOV AX, A[SI][DI]

Следует
заметить, что следующие записи эквиваленты
(A и B – некоторые регистры-модификаторы):

[A][B] = [A]+[B] =
[A+B]

В
рассмотренном примере для получения
адреса переменной A мы ввели дополнительную
переменную B. Однако для загрузки
исполнительного адреса операнда в
памяти существует специальная команда
LEA (табл. 12). Полученный результат заносится
в регистр общего назначения. Флаги
команда не изменяет. В качестве первого
операнда команды должен быть указан
регистр общего назначения, а в качестве
второго – адресное выражение.

Табл. 12. Команда LEA.

Команда
LEA может ссылаться на операнд источника
с помощью любого типа адресации, который
можно указать байтом ModRegR/M. Поля Mod и R/M
байта ModRegR/M используются при вычислении
адреса. Поле Reg этого байта определяет
регистр общего назначения, в который
должен быть занесён адрес.

Во
многих случаях команда LEA идентична
команде MOV с непосредственным операндом.
Например, следующие две команды выполняют
одинаковое действие:

MOV BX, OFFSET A

LEA BX, A

В первом
случае выполняется непосредственная
пересылка, которая использует смещение
переменной A относительно начала сегмента
данных. Оператор OFFSET сообщает транслятору,
что в регистр BX надо загрузить смещение
адресного значения переменной A. Команда
LEA вычисляет действительный адрес
переменной A и помещает его в регистр
BX.

Для
загрузки в регистр BX адреса десятого
байта массива, на который указывает
регистр DI. Пример применение команды
LEA следующий:

LEA BX, 10[DI]

Ассемблер
обратится по адресу содержимого регистра
DI, добавит смещение 10, и затем поместит
это значение (адрес) в регистр BX.
Аналогичной команды с непосредственным
операндом MOV для выполнения той же
функции не существует.

Механизм
адресации микропроцессора 8086 требует
определения сегмента и смещения каждой
переменной. Такое действие можно
выполнить с помощью команд загрузки
дальнего указателя LDS и LES (табл. 13). По
команде LDS(LES)
в сегментный регистр DS (ES)
и в указанный регистр общего назначения
загружается дальний указатель, значение
которого находится в указанной области
памяти. Флаги команда не изменяет.

Табл.
13. Команды загрузки дальнего указателя.

Например,
команда:

LDS SI, A

загружает регистровую
пару DS:SI значениями сегмента и смещения,
содержащимися в переменной A: в регистр
SI помещается смещение, расположенное
по адресу A, а в регистр DS – значение
сегмента, расположенное по адресу A+2.

И
последняя инструкция, используемая в
операциях модификации адресов, XLAT (табл.
14). Инструкция перекодирует по таблице
значение регистра AL. Команда помещает
в регистр AL содержимое байта памяти по
адресу, равному сумме содержимого
регистров BX и AL. Флаги команда не меняет.
Команда используется при перекодировке
символов.

Табл. 14. Команда XLAT.

Предположим,
имеется таблица кодировки символов
размером до 256 байтов, и i-й элемент
рассматривается как новый код символа
с кодом i. Если начальный адрес таблицы
поместить в регистр BX, а исходный код
перекодируемого символа в регистр AL,
то команда XLAT поместит в регистр AL новый
код символа из i-ого элемента таблицы.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #