This chapter focuses on the basic building blocks of assembly language, including defining constants and variables, integer and string literals, labels, directives, instructions, operands, and comments. It discusses basic data types like BYTE, WORD, DWORD and defining data sections. Key concepts are integer and string expressions, character encoding, reserved words, identifiers, and commenting code. Examples are provided to illustrate instructions, directives, defining variables, and overall program structure.
This chapter focuses on the basic building blocks of assembly language, including defining constants and variables, integer and string literals, labels, directives, instructions, operands, and comments. It discusses basic data types like BYTE, WORD, DWORD and defining data sections. Key concepts are integer and string expressions, character encoding, reserved words, identifiers, and commenting code. Examples are provided to illustrate instructions, directives, defining variables, and overall program structure.
This chapter focuses on the basic building blocks of assembly language, including defining constants and variables, integer and string literals, labels, directives, instructions, operands, and comments. It discusses basic data types like BYTE, WORD, DWORD and defining data sections. Key concepts are integer and string expressions, character encoding, reserved words, identifiers, and commenting code. Examples are provided to illustrate instructions, directives, defining variables, and overall program structure.
This chapter focuses on the basic building blocks of assembly language, including defining constants and variables, integer and string literals, labels, directives, instructions, operands, and comments. It discusses basic data types like BYTE, WORD, DWORD and defining data sections. Key concepts are integer and string expressions, character encoding, reserved words, identifiers, and commenting code. Examples are provided to illustrate instructions, directives, defining variables, and overall program structure.
• This chapter focuses on the basic building blocks of the Microsoft MASM assembler. • You will see how constants and variables are defined, standard formats for numeric and string literals, and how to assemble and run your first programs.
2 Basic Language elements
3 Basic Language elements
4 Integer Literal • An integer literal (also known as an integer constant) is made up of an optional leading sign, one or more digits, and an optional radix character that indicates the number’s base.
• So, for example, 26 is a valid integer literal. It doesn’t have a radix, so we assume it’s in decimal format. If we wanted it to be 26 hexadecimal, we would have to write it as 26h. Similarly, the number 1101 would be considered a decimal value until we added a “b” at the end to make it 1101b (binary). • A hexadecimal literal beginning with a letter must have a leading zero to prevent the assembler from interpreting it as an identifier. 5 Integer expression • An integer expression is a mathematical expression involving integer values and arithmetic operators • The integer expression must evaluate to an integer, which can be stored in 32 bits (0 through FFFFFFFFh)
6 Real Number literals • Real number literals (also known as floating-point literals) are represented as either decimal reals or encoded (hexadecimal) reals. • A decimal real contains an optional sign followed by an integer, a decimal point, an optional integer that expresses a fraction, and an optional exponent
7 Character literals • A character literal is a single character enclosed in single or double quotes. The assembler stores the value in memory as the character’s binary ASCII code.
• Ex: ‘D’, “d”
String literals • A string literal is a sequence of characters (including spaces) enclosed in single or double quotes: • Examples: 'ABC‘ 'X‘ "Good night, Gracie“ '4096' 8 Reserved words • Reserved words have special meaning and can only be used in their correct context. Reserved works, by default, are not case-sensitive. • For example, MOV is the same as mov and Mov. • There are different types of reserved words: • Instruction mnemonics, such as MOV, ADD, and MUL • Register names • Directives, which tell the assembler how to assemble programs • Attributes, which provide size and usage information for variables and operands. Examples are BYTE and WORD • Operators, used in constant expressions • Predefined symbols, such as @data, which return constant integer values at assembly time
9 Identifier • An identifier is a programmer-chosen name. It might identify a variable, a constant, a procedure, or a code label. There are a few rules on how they can be formed: • They may contain between 1 and 247 characters. • They are not case sensitive. • The first character must be a letter (A..Z, a..z), underscore (_), @ , ?, or $. Subsequent characters may also be digits. • An identifier cannot be the same as an assembler reserved word.
10 Directive • A directive is a command embedded in the source code that is recognized and acted upon by the assembler. • One important function of assembler directives is to define program sections, or segments. Segments are sections of a program that have different purposes. • For example, one segment can be used to define variables, and is identified by the .DATA directive: .data • The .CODE directive identifies the area of a program containing executable instructions: .code • The .STACK directive identifies the area of a program holding the runtime stack, setting its size: .stack 100h • DWORD
11 Directive Vs Instruction
12 Instruction An instruction is a statement that becomes executable when a program is assembled. Instructions are translated by the assembler into machine language bytes, which are loaded and executed by the CPU at runtime. An instruction contains four basic parts: • Label (optional) • Instruction mnemonic (required) • Operand(s) (usually required) • Comment (optional) • Basic syntax [label:] mnemonic [operands] [ ; comment]
13 Labels • Act as place markers • marks the address (offset) of code and data • Follow identifier rules • Data label • must be unique • example: myArray (not followed by colon) • count DWORD 100 • Code label • target of jump and loop instructions • example: L1: (followed by colon)
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010. 14
Mnemonics • An instruction mnemonic is a short word that identifies an instruction.
Operands • Constants and constant expressions are often called immediate values
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010. 15
Instruction Format Examples • No operands stc ; set Carry flag • One operand inc eax ; register inc myByte ; memory • Two operands add ebx, ecx ; register, register sub myByte, 25 ; memory, constant add eax, 36 * 25 ; register, constant-expression
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010. 16
Comments • Comments are an important way for the writer of a program to communicate information about the program’s design to a person reading the source code. Comments can be specified in two ways: • Single-line comments, beginning with a semicolon character (;). All characters following the semicolon on the same line are ignored by the assembler. • Block comments, beginning with the COMMENT directive and a user- specified symbol. • Example:
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
EXAMPLE
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
EXPLANATION • Line 4 contains the .386 directive, which identifies this as a 32-bit program that can access 32-bit registers and addresses. • Line 5 selects the program’s memory model (flat), and identifies the calling convention (named stdcall) for procedures. The std call keyword tells the assembler how to manage the runtime stack when procedures are called. • Line 6 sets aside 4096 bytes of storage for the runtime stack. It tells the assembler how many bytes of memory to reserve for the program’s runtime stack. • The .CODE directive marks the beginning of the code area of a program, the area that contains executable instructions. • When your program is ready to finish, it calls Exit Process that returns an integer that tells the operating system that your program worked just fine.
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
EXPLANATION [Cont.]
• The ENDP directive marks the end of a procedure. Our program had a procedure named main, so the endp must use the same name: main ENDP • Finally, the END directive marks the end of the program, and references the program entry point: END main
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data
• The assembler recognizes a basic set of intrinsic datatypes, which describe
types in terms of their size.
• Initializer: At least one initializer is required in a data definition, even if it is zero
• If you prefer to leave the variable uninitialized (assign a random value), the ? Symbol can be used as a initializer
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
• Defining BYTE and SBYTE Data
The BYTE (define byte) and SBYTE (define signed byte) directives allocate storage for one or more unsigned or signed values. Each initializer must fit into 8 bits of storage. For example, value1 BYTE 'A' ; character literal value2 BYTE 0 ; smallest unsigned byte value3 BYTE 255 ; largest unsigned byte value4 SBYTE −128 ; smallest signed byte
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
The DB directive can also define an 8-bit variable, signed or unsigned:
val1 DB 255 ; unsigned byte
val2 DB -128 ; signed byte
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.] • Multiple Initializers • If multiple initializers are used in the same data definition, its label refers only to the offset of the first initializer. • In the following example, assume list is located at offset 0000. If so, the value 10 is at offset 0000, 20 is at offset 0001, 30 is at offset 0002, and 40 is at offset 0003: list BYTE 10,20,30,40
• Within a single data definition, its initializers can use different radixes. Character and string literals can be freely mixed. In the following example, list1 and list2 have the same contents: list1 BYTE 10, 32, 41h, 00100010b list2 BYTE 0Ah, 20h, 'A', 22h
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
Defining Strings To define a string of characters, enclose them in single or double quotation marks. The most common type of string ends with a null byte (containing 0), Called a null-terminated string.
Example: greeting1 BYTE "Good afternoon",0 greeting2 BYTE 'Good night',0 Each character uses a byte of storage. Strings are an exception to the rule that byte values must be separated by commas.
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
Defining Strings
• A string can be divided between multiple lines without having to supply a label for each line: greeting1 BYTE "Welcome to the Encryption Demo program " BYTE "created by Kip Irvine.",0dh,0ah BYTE "If you wish to modify this program, please " BYTE "send me a copy.",0dh,0ah,0 The hexadecimal codes 0Dh and 0Ah are alternately called CR/LF (carriage-return line-feed) or end-of-line characters.
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
DUP Operator The DUP operator allocates storage for multiple data items, using a integer expression as a counter. It is particularly useful when allocating space for a string or array, and can be used with initialized or uninitialized data: BYTE 20 DUP(0) ; 20 bytes, all equal to zero BYTE 20 DUP(?) ; 20 bytes, uninitialized BYTE 4 DUP("STACK") ; 20 bytes: "STACKSTACKSTACKSTACK” var4 BYTE 10,3 DUP(0), 20
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.] Defining WORD and SWORD Data The WORD (define word) and SWORD (define signed word) directives create storage for one or more 16-bit integers:
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
The legacy DW directive can also be used:
val1 DW 65535 ; unsigned val2 DW -32768 ; signed
MyList WORD 1,2,3,4,5
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
Defining DWORD and SDWORD Data
• The DWORD directive (define doubleword) and SDWORD directive (define signed doubleword) allocate storage for one or more 32-bit integers:
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.]
Little endian order
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
Defining Data [Cont.] Declaring Uninitialized Data The .DATA? directive declares uninitialized data. When defining a large block of uninitialized data, the .DATA? directive reduces the size of a compiled program. For example, the following code is declared efficiently: .data smallArray DWORD 10 DUP(0) ; 40 bytes .data? bigArray DWORD 5000 DUP(?) ; 20,000 bytes, not initialized
The following code, on the other hand, produces a compiled program 20,000 bytes larger: .data smallArray DWORD 10 DUP(0) ; 40 bytes bigArray DWORD 5000 DUP(?) ; 20,000 bytes
Irvine, Kip R. Assembly Language for x86 Processors 6/e, 2010.
