ASM-Lect03

Assembly Language Fundamentals

Authors and Edition

  • Assembly Language for x86 Processors, 7th Edition

  • Prepared by: Kip Irvine, Donia Gamal

Comments in Assembly Language

  • Single Line Comment

    • Syntax can be placed at the end or beginning of a line to clarify code, making it easier to understand for human readers:

      • Example: inc eax ; single line comment

      • This indicates the increment operation while explaining its purpose.

  • Multiline Comment

    • Defined using the COMMENT directive, which helps in documenting larger sections of code:

      • Example: COMMENT ! This is a comment!

      • Useful for providing extensive descriptions or intentions behind complex code structures.

Symbolic Constants

Equal-Sign Directive

  • Used to define a symbolic constant for better clarity and maintainability:

    • Syntax: name = expression

    • Example: COUNT = 500

  • This approach allows for redefinition of constants throughout the program, enhancing flexibility.

Calculating Sizes of Arrays and Strings

  • Utilizes the location counter $ to find sizes of dynamically sized data structures. This aids in memory management:

    • For byte arrays: ListSize = ($ - list)

    • For word arrays: ListSize = ($ - list) / 2

    • Understanding the sizes is crucial for buffer management and avoiding overflow errors.

EQU and TEXTEQU Directives

EQU Directive

  • Defines a symbol as either an integer or text and cannot be redefined:

    • Examples:

      • PI EQU 3.1416

      • pressKey EQU 0x0A – can represent hardware constants.

TEXTEQU Directive

  • Defines symbols that can be redefined and may contain more complex expressions:

    • Example: continueMsg TEXTEQU "Press any key to continue..."

    • This makes the code more readable and modifiable, especially in message management.

General-Purpose Registers

  • Registers Overview

    • 16-bit Segment Registers: CS (Code Segment), SS (Stack Segment), DS (Data Segment), ES (Extra Segment)

    • 32-bit General-Purpose Registers: EAX (Accumulator), EBX (Base), ECX (Counter), EDX (Data), FS, GS (Pointer registers), EBP (Base Pointer), ESP (Stack Pointer), ESI (Source Index), EDI (Destination Index)

  • Data representation in registers varies:

    • AL: 8 bits, AX: 16 bits, EAX: 32 bits – each increasing in size accommodates larger data operations effectively.

Data Directive Examples

  • Examples of how to define data types for better data management:

    • ByteVal0 BYTE ? – uninitialized byte.

    • ByteVal1 BYTE 48 – specifies a byte initialized to 48.

    • String1 BYTE 'Hello' – defines a string as a sequence of bytes.

    • Dup(5) DWVar DWORD 234553H – creates multiple DWORD entries initialized to a specific value, promoting efficient storage.

Signed and Unsigned Integers

  • Signed Integers

    • The highest bit represents the sign (1 for negative and 0 for positive).

    • Negative values in hexadecimal format can be identified when the highest digit is greater than 7 (e.g., 8A, C5).

  • Unsigned Integers

    • Represent only positive values, which simplifies certain arithmetic operations but limits expressiveness for negative ranges.

Data Transfer Instructions

Basic Characteristics

  • Facilitates the transfer of data between registers or from registers to memory, essential for data manipulation.

  • The MOV instruction serves as the primary operation for data transfer:

  • Syntax: MOV dest, src

  • Source can be an immediate value, a register, or a memory reference.

MOV Instruction

  • Operand Types:

    • Immediate value (e.g., MOV EAX, 5),

    • Register (e.g., MOV EAX, EBX),

    • Memory reference (e.g., MOV EAX, [var])

  • It’s essential to note that direct transfers between memory locations are not permitted – data must first be moved to a register.

MOV Instruction Restrictions

  • Both operands must match in size to maintain data integrity.

  • Certain registers cannot receive data (e.g., CS, EIP), as these are crucial for system operation and require special handling.

Example MOV Scenarios

  • Example data initialization:

    • .data count BYTE 100

    • .data bVal BYTE 20

  • Several successful and unsuccessful MOV operations are discussed to illustrate the importance of operand size and destination validity.

Same-size Operands Constraint

  • This fundamental constraint ensures that operands must match in size, which is crucial for interpretation by the processor.

  • Safety measures for signed and unsigned integers during transfers are critical:

    • Unsigned values are filled with 0’s to preserve number integrity.

    • Signed values utilize the sign bit to maintain accurate representation across different data sizes.

MOVZX and MOVSX Instructions

  • MOVZX: Transfers a small unsigned operand to a larger size, filling the additional bits with 0’s, which is vital in data expansion without sign alteration.

  • MOVSX: Transfers a signed operand and fills the new space with the sign bit, preserving the sign in conversion.

XCHG Instruction

  • This instruction allows for the exchange of values between two operands of the same size, which is often used to swap register contents or values.

  • At least one operand must be a register to ensure speed and efficiency in execution.

Addressing Modes Overview

  • Various methods for accessing instruction operands include:

    • Register Addressing: Utilizes register names directly to access their values, enhancing speed.

    • Immediate Addressing: Where a direct value is embedded in the instruction.

    • Direct Memory Addressing: Uses variable labels to point to memory locations.

    • Direct Offset Addressing: Adds a constant offset to produce an effective address, allowing flexible memory access.

Example of Direct Offset Addressing

  • This addressing mode prompts efficient data access with calculated offsets when managing arrays and strings, boosting performance.

Array Manipulation Example

  • Demonstrating how to effectively swap the order of elements in an array:

    • Move elements to EAX, execute the exchange, and subsequently copy values back, showcasing efficient memory use and logic implementation.

Addition and Subtraction Instructions

Basic Types

  • Key instructions include ADD, SUB, INC (increment), DEC (decrement), NEG (negate).

  • The common format for these operations is: ADD/SUB destination, source, essential for performing arithmetic in assembly language.

  • Note that memory-to-memory arithmetic is not permitted, underscoring the need for register usage.

Example Addition Scenario

  • A scenario illustrates how to add three unsigned bytes stored within an array, combining multiple operands to show cumulative addition.

Flags Impacted by ADD/SUB Instructions

  • Flags that can be set will include:

    • Carry Flag (CF), Overflow Flag (OF), Sign Flag (SF), Zero Flag (ZF), Auxiliary Carry Flag (AF), Parity Flag (PF).

Importance of Flags

  • These flags play a crucial role in detecting calculation errors and enabling conditional branching based on results, which are vital for control flow in assembly programs.

Zero Flag (ZF) and Sign Flag (SF)

  • Descriptions of how and when these flags are set provide insights into program logic and conditional execution:

    • The Zero Flag is set when the result of an operation is zero, indicating potential program end conditions.

    • The Sign Flag reflects the sign of the result, which is crucial in arithmetic operations.

Additional Flags

  • Auxiliary Flag (AF) and Parity Flag (PF) examples give insight into advanced condition checking and debugging operations, thus enhancing program robustness.

Conclusion

  • Continuous progress through assembly language instructions and their fundamental concepts fosters a deeper understanding of low-level programming, preparing students for more complex chapters and practical applications in computer science.

Reference

  • Textbook Chapter: 4.1 – 4.2 (partially)