x86 Assembly Language Basics

Adding a constant offset to a data label to generate an effective address (EA). This address is then used to access the value stored in the corresponding memory location.

An instruction that replaces the contents of a register with the value stored at a specified memory address. The address is usually calculated by adding a constant offset to a data label.

In assembly language, a process that replaces the contents of a register with the contents of a memory location, while simultaneously replacing the contents of that memory location with the value of the register.

A program instruction that adds two values together.

In assembly programming, a data label is a symbolic name assigned to a memory location holding a value. For example, "arrayB BYTE 10h, 20h, 30h, 40h" defines a label called "arrayB" pointing to the first byte of the array.

To rearrange the values in an array, you can use a series of memory operations, such as moving values between registers and memory, and exchanging values within the array itself. The goal is to modify the order of values stored in the array's memory locations.

A variable that holds data in a dedicated memory location within a computer program. The name of the variable is associated with that memory location. This label enables you to access the value stored at that location.

A data type in assembly language that defines a sequence of bytes in memory. Each byte in the array can store a value, and these values can be accessed individually using their index within the array.

The NEG (Negate) instruction in assembly language performs the two's complement operation on an operand.

The NEG instruction internally uses the SUB (Subtract) instruction with the first operand set to 0, effectively subtracting the operand from 0.

The Carry flag (CF) is set when the NEG instruction results in a value outside the range of representable unsigned values.

The Overflow flag (OF) is set when the NEG instruction results in a value outside the range of representable signed values.

The Zero flag (ZF) is set when the NEG instruction produces a result of 0, meaning the value is now its own negation.

The Sign flag (SF) is set when the NEG instruction results in a negative value.

The MOV (Move) instruction does not modify any of the status flags.

The ALU (Arithmetic Logic Unit) is responsible for performing arithmetic operations and setting the status flags based on the results. These flags are useful for conditional branching and other operations.

An indirect or indexed operand can be scaled to the offset of an array element by multiplying the index by the array's data type size.

A pointer variable is declared to store the offset of another variable, allowing indirect access to the variable's data.

The offset of an array element is determined by multiplying the index by the array's data type size. This allows you to access specific elements within the array.

General-purpose registers can be used as indirect operands, allowing for flexible address manipulation.

The EBX register is often used for addressing the stack, a dedicated memory area for storing function parameters and local variables.

Indicates whether the result of a signed arithmetic operation is outside the valid range for signed numbers. It's set when adding two positive numbers results in a negative value or adding two negative numbers results in a positive value.

The Overflow flag is set when the signed result of an operation is invalid or out of range. When a sign change is observed, the Overflow flag will be set. Example: mov al,+127; add al,1 The Overflow flag is set, and the result of this operation will be -128 or 0x80.

The Overflow flag is set when the signed result of an operation is invalid or out of range. When a sign change is observed, the Overflow flag will be set. Example: mov al,7Fh; add al,1 The Overflow flag is set, and the result of this operation will be -128 or 0x80.

The Overflow flag is only set when adding two numbers with the same sign and their sum is a number with the opposite sign.

The Overflow flag is set because adding 80h (128) and 92h (146) produces a result that is outside the range of signed 8-bit numbers (0 to 127).

The Overflow flag is not set in this example, because adding -2 and +127 results in a valid signed 8-bit number (125), and there's no sign change involved.

When adding two integers, the Overflow flag is only set when... Two positive operands are added and their sum is negative. Two negative operands are added and their sum is positive.

The Overflow flag is only set when adding two numbers with the same sign and their sum is a number with the opposite sign.

The LENGTHOF operator counts the number of elements in a single data declaration. For example, LENGTHOF array1 would return 32 because array1 is declared as WORD 30 DUP(?),0,0. The array1 declaration contains 32 elements, 30 duplicates of (?) (unknown values) followed by two zeros.

The SIZEOF operator calculates the total size of a data declaration in bytes by multiplying the number of elements (found with LENGTHOF) by the size of each element (defined by its data type). For example, SIZEOF array1 would return 64 because array1 is declared as WORD 30 DUP(?),0,0. Each WORD element takes up 2 bytes, so the total size is 32 * 2 = 64 bytes.

A data declaration can span multiple lines when each line (except the last) ends with a comma. Both the LENGTHOF and SIZEOF operators will take into account all lines belonging to that declaration.

In a multi-line declaration, the name given to the data declaration identifies only the first line in the declaration. The LENGTHOF and SIZEOF operators will work on the entire multiline declaration.

The TYPE operator provides information about the data type of a variable. It returns a value that represents the size of the data type.

The array variable in this example is declared as WORD and includes multiple elements (10 through 60). LENGTHOF array returns the number of elements in the declaration, which is 6. SIZEOF array returns the total size of the declaration in bytes, which is 12 (because there are 6 elements and each element takes up 2 bytes).

A data declaration that starts with a BYTE data type defines each element as a single byte. The SIZEOF operator returns the size of the entire declaration in bytes.

Data declarations that use word (WORD) data types assign each element a size of 2 bytes (bytes). The SIZEOF operator returns the size in bytes of the entire declaration.

A loop that executes a specific number of times, determined by the value in the ECX register. The LOOP instruction automatically decrements ECX by 1 and jumps back to the loop's beginning if ECX is not zero. When ECX reaches zero, the loop terminates.

A way to create a loop that repeats a particular number of times, controlled by a pre-defined counter value stored in the ECX register.

A powerful way to control the flow of your program by repeatedly executing a block of code until a specific condition is met. This enables you to repeat tasks without writing the same code over and over.

If the relative offset is encoded in a single signed byte, the largest possible forward jump is +127 bytes. This means it can jump ahead up to 127 bytes from the current instruction location.

If the relative offset is encoded in a single signed byte, the largest possible backward jump is -128 bytes, which allows for jumping back up to 128 bytes from the current instruction location.

A technique in assembly language where you create a loop inside another loop. This allows you to create more complex algorithms that involve nested repetitions.

Saving the outer loop counter's ECX value before entering the inner loop ensures that the outer loop's counter is not accidentally overwritten by the inner loop's operations.

A loop that executes a specific number of times, determined by the value in the ECX register. The LOOP instruction automatically decrements ECX by 1 and jumps back to the loop's beginning if ECX is not zero. When ECX reaches zero, the loop terminates.