Assembly Language
An assembly language is a low-level programming language designed for a specific
type of processor. It may be produced by compiling source code from a high-level
programming language (such as C/C++) but can also be written from scratch. Assembly
code can be converted to machine code using an assembler.
Since most compilers convert source code directly to machine code, software
developers often create programs without using assembly language. However, in some
cases, assembly code can be used to fine-tune a program. For example, a programmer
may write a specific process in assembly language to make sure it functions as
efficiently as possible.
While assembly languages differ between processor architectures, they often
include similar instructions and operators. Below are some examples of instructions
supported by x86 processors.
MOV - move data from one location to another
ADD - add two values
SUB - subtract a value from another value
PUSH - push data onto a stack
POP - pop data from a stack
JMP - jump to another location
INT - interrupt a process
The following assembly language can be used to add the numbers 3 and 4:
mov eax, 3 - loads 3 into the register "eax"
mov ebx, 4 - loads 4 into the register "ebx"
add eax, ebx, ecx - adds "eax" and "ebx" and stores the result (7) in "ecx"
Writing assembly language is a tedious process since each operation must be
performed at a very basic level. While it may not be necessary to use assembly code to
create a computer program, learning assembly language is often part of a Computer
Science curriculum since it provides useful insight into the way processors work.
List of Useful and Frequently Used DOS Command
This list of DOS commands is very useful when repairing Windows after a system
crash when Windows doesn’t load and the only option you have is a Dos command
prompt. Use the “help” command to find the usage and details of any particular
command e.g. C:\>help copy
CHDIR – Displays the name of or changes the current directory.
CHKDSK – Checks a disk and displays a status report.
CLS – Clears the screen.
COMP – Compares two groups of files to find information that does not match.
COPY – Copies and appends files.
DATE – Displays and/or sets the system date.
DEFRAG – Optimizes disk performance by reorganizing the files on the disk.
DEL – Deletes files from disk.
DELTREE – Deletes a directory including all files and subdirectories that are in it.
DIR – Displays directory of files and directories stored on disk.
DISKCOMP – Compares the contents of two diskettes.
ECHO – Displays messages or turns on or off the display of commands in a batch file.
EDIT – Starts the MS-DOS editor, a text editor used to create and edit ASCII text files.
EXIT – Exits a secondary command processor.
EXPAND – Expands a compressed file.
FASTHELP – Displays a list of DOS commands with a brief explanation of each.
FIND – Finds and reports the location of a specific string of text characters in one or
more files.
FOR – Performs repeated execution of commands (for both batch processing and
interactive processing).
FORMAT – Formats a disk to accept DOS files.
GRAPHICS – Provides a way to print contents of a graphics screen display.
IF – Allows for conditional operations in batch processing.
LABEL – Creates or changes or deletes a volume label for a disk.
MEM – Displays amount of installed and available memory, including extended,
expanded, and upper memory.
MKDIR – Creates a new subdirectory.
MORE – Sends output to console, one screen at a time.
MOVE – Moves one or more files to the location you specify. Can also be used to
rename directories.
PATH – Sets or displays directories that will be searched for programs not in the
current directory.
RENAME – Changes the filename under which a file is stored.
RMDIR – Removes a subdirectory.
SORT – Sorts input and sends it to the screen or to a file.
XCOPY – Copies directories, subdirectories, and files.
Assembler
An assembler is a program that converts assembly language into machine code. It takes
the basic commands and operations from assembly code and converts them
into binary code that can be recognized by a specific type of processor.
Assemblers are similar to compilers in that they produce executable code. However,
assemblers are more simplistic since they only convert low-level code (assembly
language) to machine code. Since each assembly language is designed for a specific
processor, assembling a program is performed using a simple one-to-one mapping from
assembly code to machine code. Compilers, on the other hand, must convert generic
high-level source code into machine code for a specific processor.
Most programs are written in high-level programming languages and are compiled
directly to machine code using a compiler. However, in some cases, assembly code may
be used to customize functions and ensure they perform in a specific way.
Therefore, IDEs often include assemblers so they can build programs from both high
and low-level languages.
Preprocessor Directives
Preprocessor directives are lines included in a program that begin with the
character #, which make them different from a typical source code text. They are
invoked by the compiler to process some programs before compilation. Preprocessor
directives change the text of the source code and the result is a new source code without
these directives.
Although preprocessing in C# is conceptually similar to that in C/C++, it is different
in two aspects. First, preprocessing in C# does not involve a separate step for
preprocessor execution before compilation. It is processed as a part of the lexical
analysis phase. Second, it cannot be used to create macros. In addition, the new
directives #region and #unregion have been added in C# along with the exclusion of
some directives used earlier (#include is a notable directive whose use is replaced with
"using" to include assemblies).
Java does not support preprocessor directives.
A preprocessor directive is usually placed in the top of the source code in a separate
line beginning with the character "#", followed by directive name and an optional white
space before and after it. Because a comment on the same line of declaration of the
preprocessor directive has to be used and cannot scroll through the following line,
delimited comments cannot be used. A preprocessor directive statement must not end
with a semicolon (;). Preprocessor directives can be defined in source code or in the
common line as argument during compilation.
Examples for preprocessing directives that can be used in C# include:
#define and #undef: To define and undefine conditional compilation
symbols, respectively. These symbols could be checked during compilation
and the required section of source code can be compiled. The scope of a
symbol is the file in which it is defined.
#if, #elif, #else, and #endif: To skip part of source code based on conditions.
Conditional sections may be nested with directives forming complete sets.
#line: To control line numbers generated for errors and warning. This is
mostly used by meta-programming tools to generate C# source code from
some text input. It is generally used to modify the line numbers and source
file names reported by the compiler in its output.
#error and #warning : To generate errors and warnings, respectively.
#error is used to stop compilation, while #warning is used to continue
compilation with messages in the console.
#region and #endregion :To explicitly mark sections of source code. These
allow expansion and collapse inside Visual Studio for better readability and
reference.
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
ASCII adjust AL after used with unpacked binary coded
AAA 0x37
addition decimal
8086/8088 datasheet documents
only base 10 version of the AAD
instruction (opcode 0xD5 0x0A),
but any other base will work.
Later Intel's documentation has
ASCII adjust AX before
AAD the generic form too. NEC V20 0xD5
division
and V30 (and possibly other NEC
V-series CPUs) always use base
10, and ignore the argument,
causing a number of
incompatibilities
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
Only base 10 version (Operand is
ASCII adjust AX after
AAM 0xA) is documented, see notes 0xD4
multiplication
for AAD
ASCII adjust AL after
AAS 0x3F
subtraction
0x10…0x15,
destination := destination +
ADC Add with carry 0x80/2…0x
source + carry_flag
83/2
0x00…0x05,
(1) r/m += r/imm; (2) r +=
ADD Add 0x80/0…0x
m/imm;
83/0
0x20…0x25,
(1) r/m &= r/imm; (2) r &=
AND Logical AND 0x80/4…0x
m/imm;
83/4
0x9A, 0xE8,
push eip; eip points to the
CALL Call procedure 0xFF/2,
instruction directly after the call
0xFF/3
CBW Convert byte to word 0x98
CLC Clear carry flag CF = 0; 0xF8
CLD Clear direction flag DF = 0; 0xFC
CLI Clear interrupt flag IF = 0; 0xFA
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
CMC Complement carry flag 0xF5
0x38…0x3D,
CMP Compare operands 0x80/7…0x
83/7
Compare bytes in
CMPSB 0xA6
memory
CMPSW Compare words 0xA7
Convert word to
CWD 0x99
doubleword
Decimal adjust AL after (used with packed binary coded
DAA 0x27
addition decimal)
Decimal adjust AL after
DAS 0x2F
subtraction
0x48…0x4F,
DEC Decrement by 1 0xFE/1,
0xFF/1
DX:AX = DX:AX / 0xF6/6,
DIV Unsigned divide
r/m; resulting DX == remainder 0xF7/6
Used
ESC 0xD8..0xDF
with floating-point unit
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
HLT Enter halt state 0xF4
DX:AX = DX:AX / 0xF6/7,
IDIV Signed divide
r/m; resulting DX == remainder 0xF7/7
0x69, 0x6B
(both since
80186),
(1) DX:AX = AX * r/m; (2) AX = 0xF6/5,
IMUL Signed multiply
AL * r/m 0xF7/5,
0x0FAF
(since
80386)
(1) AL = port[imm]; (2) AL =
0xE4, 0xE5,
IN Input from port port[DX]; (3) AX =
0xEC, 0xED
port[imm]; (4) AX = port[DX];
0x40…0x47,
INC Increment by 1 0xFE/0,
0xFF/0
INT Call to interrupt 0xCC, 0xCD
Call to interrupt if
INTO 0xCE
overflow
IRET Return from interrupt 0xCF
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
(JA, JAE, JB, JBE, JC, JE, JG,
0x70…0x7F,
JGE, JL, JLE, JNA, JNAE, JNB,
0x0F80…0x
Jcc Jump if condition JNBE, JNC, JNE, JNG, JNGE,
0F8F (since
JNL, JNLE, JNO, JNP, JNS, JNZ,
80386)
JO, JP, JPE, JPO, JS, JZ)
JCXZ Jump if CX is zero 0xE3
0xE9…0xEB
JMP Jump , 0xFF/4,
0xFF/5
Load FLAGS into AH
LAHF 0x9F
register
LDS Load pointer using DS 0xC5
LEA Load Effective Address 0x8D
LES Load ES with pointer 0xC4
Assert BUS LOCK#
LOCK (for multiprocessing) 0xF0
signal
if (DF==0) AL = *SI++; else AL =
LODSB Load string byte 0xAC
*SI--;
if (DF==0) AX = *SI++; else AX
LODSW Load string word 0xAD
= *SI--;
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
LOOP/LO (LOOPE, LOOPNE, LOOPNZ,
Loop control 0xE0…0xE2
OPx LOOPZ) if (x && --CX) goto lbl;
copies data from one location to
MOV Move 0xA0...0xA3
another, (1) r/m = r; (2) r = r/m;
if (DF==0)
Move byte from string *(byte*)DI++ = *(byte*)SI++;
MOVSB 0xA4
to string else
*(byte*)DI-- = *(byte*)SI--;
if (DF==0)
Move word from string *(word*)DI++ =
MOVSW 0xA5
to string *(word*)SI++; else
*(word*)DI-- = *(word*)SI--;
(1) DX:AX = AX * r/m; (2) AX = 0xF6/4…0x
MUL Unsigned multiply
AL * r/m; F7/4
Two's complement 0xF6/3…0x
NEG r/m *= -1;
negation F7/3
opcode equivalent to XCHG EAX,
NOP No operation 0x90
EAX
Negate the 0xF6/2…0x
NOT r/m ^= -1;
operand, logical NOT F7/2
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
0x08…0x0D
(1) r/m |= r/imm; (2) r |= m/im ,
OR Logical OR
m; 0x80…0x83
/1
(1) port[imm] = AL; (2) port[DX]
0xE6, 0xE7,
OUT Output to port = AL; (3) port[imm] =
0xEE, 0xEF
AX; (4) port[DX] = AX;
0x07,
r/m = *SP++; POP CS (opcode 0x0F(8086/
0x0F) works only on 8086/8088. 8088 only),
POP Pop data from stack
Later CPUs use 0x0F as a prefix 0x17, 0x1F,
for newer instructions. 0x58…0x5F,
0x8F/0
Pop FLAGS
POPF FLAGS = *SP++; 0x9D
register from stack
0x06, 0x0E,
0x16, 0x1E,
0x50…0x57,
PUSH Push data onto stack *--SP = r/m; 0x68, 0x6A
(both since
80186),
0xFF/6
PUSHF Push FLAGS onto stack *--SP = FLAGS; 0x9C
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
0xC0…0xC1
/2 (since
RCL Rotate left (with carry) 80186),
0xD0…0xD3
/2
0xC0…0xC1
/3 (since
Rotate right (with
RCR 80186),
carry)
0xD0…0xD3
/3
Repeat
(REP, REPE, REPNE, REPNZ,
REPxx MOVS/STOS/CMPS/L 0xF2, 0xF3
REPZ)
ODS/SCAS
Not a real instruction. The
assembler will translate these to a
RET Return from procedure RETN or a RETF depending on
the memory model of the target
system.
Return from near
RETN 0xC2, 0xC3
procedure
Return from far
RETF 0xCA, 0xCB
procedure
ROL Rotate left 0xC0…0xC1
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
/0 (since
80186),
0xD0…0xD3
/0
0xC0…0xC1
/1 (since
ROR Rotate right 80186),
0xD0…0xD3
/1
SAHF Store AH into FLAGS 0x9E
0xC0…0xC1
/4 (since
Shift Arithmetically left
SAL (1) r/m <<= 1; (2) r/m <<= CL; 80186),
(signed shift left)
0xD0…0xD3
/4
0xC0…0xC1
/7 (since
Shift Arithmetically (1) (signed) r/m >>=
SAR 80186),
right (signed shift right) 1; (2) (signed) r/m >>= CL;
0xD0…0xD3
/7
alternative 1-byte encoding 0x18…0x1D,
Subtraction with
SBB of SBB AL, AL is available 0x80…0x83
borrow
via undocumented SALC /3
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
instruction
SCASB Compare byte string 0xAE
SCASW Compare word string 0xAF
0xC0…0xC1
/4 (since
Shift left (unsigned shift
SHL 80186),
left)
0xD0…0xD3
/4
0xC0…0xC1
/5 (since
Shift right (unsigned
SHR 80186),
shift right)
0xD0…0xD3
/5
STC Set carry flag CF = 1; 0xF9
STD Set direction flag DF = 1; 0xFD
STI Set interrupt flag IF = 1; 0xFB
if (DF==0) *ES:DI++ = AL; else *
STOSB Store byte in string 0xAA
ES:DI-- = AL;
if (DF==0) *ES:DI++ = AX; else
STOSW Store word in string 0xAB
*ES:DI-- = AX;
Original 8086/8088 instruction set
Instruct
Meaning Notes Opcode
ion
0x28…0x2D,
(1) r/m -= r/imm; (2) r -=
SUB Subtraction 0x80…0x83
m/imm;
/5
0x84, 0x84,
0xA8, 0xA9,
TEST Logical compare (AND) (1) r/m & r/imm; (2) r & m/imm;
0xF6/0,
0xF7/0
Waits until BUSY# pin is inactive
WAIT Wait until not busy 0x9B
(used with floating-point unit)
r :=: r/m; A spinlock typically
0x86, 0x87,
XCHG Exchange data uses xchg as an atomic operation.
0x91…0x97
(coma bug).
Table look-up
XLAT behaves like MOV AL, [BX+AL] 0xD7
translation
0x30…0x35,
(1) r/m ^= r/imm; (2) r ^=
XOR Exclusive OR 0x80…0x83
m/imm;
/6
