Chapter 2

•  Data Representation
•  Two's Complement
•  ASCII
•  Data Defining Pseudo Operations
•  Constant Definitions
•  Internal Registers of Intel Processor
•  Data Exchange
•  Stack
•  Addressing Modes
•  Intel Register Set
•  Physical Memory
•  Memory Addressing
•  Assembly Program Structure
•  Address Accessing Operators and Instructions

Data Representation

• Unsigned - All numbers are positive.

 

Unsigned 4 bit numbers

Decimal	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
Unsigned	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010	1011	1100	1101	1110	1111

Range of 4 bit unsigned - 0 to 2⁴-1 or 0 to 15 (i.e. 0000₂ to 1111₂)
Range of 8 bit unsigned - 0 to 2⁸-1 or 0 to 255 (i.e. 00000000₂ to 11111111₂)
Range of 16 bit unsigned - 0 to 2¹⁶-1 or 0 to 65535 (i.e. 0000000000000000₂ to 1111111111111111₂)

Range of 32 bit unsigned - 0 to 2³² - 1 or 0 to 4,294,967,295 (i.e. 00000000000000000000000000000000₂ to 11111111111111111111111111111111₂)
Range of n bit unsigned - 0 to 2ⁿ-1

• Signed - Both positive and negative numbers, a specific representation must be selected. Normally the leftmost bit is used as a sign bit. 0 implies positive or + and 1 implies negative or -.
• Subtraction - Subtraction can be done using addition: 3 - 5 = 3 + (-5) = -2
• Signed Magnitude - The leftmost bit is the sign, the remaining bits are the magnitude. Problem: cannot do arithmetic.

0011 = 3            0101 = 5                3      3      0011     3
1011 = -3           1101 = -5              -5   +(-5)    +1101  +(-5)
                                           -2     -2     10000     0

• One's Complement - Negative numbers only, convert from positive to negative by inverting all bits (e.g. invert 1 to 0, 0 to 1). Can do arithmetic.

0011 = 3            0101 = 5                3      3      0011     3
1100 = -3           1010 = -5              -5   +(-5)    +1010  +(-5)
                                           -2     -2      1101    -2

• Two's Complement  - Negative numbers only, convert from positive to negative by forming one's complement and adding 1. Can do arithmetic.

    0011 = 3            0101 = 5                3      3      0011     3
1's 1100 = -3           1010 = -5              -5   +(-5)    +1011  +(-5)
      +1                  +1                   -2     -2      1110    -2
2's 1101                1011

 
Range of 4 bit two's complement  -2^4-1 to 2^4-1-1 or -8 to 7 (i.e. 1000₂ to 0111₂)
Range of 8 bit two's complement   -2^8-1 to 2^8-1-1 or -128 to 127 (i.e. 10000000₂ to 01111111₂)
Range of 16 bit two's complement   -2^16-1 to 2^16-1-1 or -32768 to 32767 (i.e. 1000000000000000₂ to 0111111111111111₂)

Range of 32 bit two's complement -2^32-1 to 2^32-1 or -2,147,483,648 to 2,147,483,647 (i.e. 10000000000000000000000000000000₂ to 01111111111111111111111111111111₂)
Range of n bit two's complement   -2^n-1 to 2^n-1-1

ASCII - 

Using the Appendix E, page A-115, the character A is in row 4 and column 1 so is code 41₁₆. Character M is in row D₁₆ and column 4 so is code D4₁₆.

ASCII chart

Data Defining Pseudo Operations

1. DB - Define Byte data, 8 bits
2. DW - Define Word data, 16 bits. Stored in reverse byte order. 1234h stored as 34 12.
3. DD - Define Double word data, 32 bits. Stored in reverse byte order. 12345678h stored as 78 56 34 12.

               Data    Segment                     Offset        Contents     
   Offset                                 Memory       0000 0F 00 1B 43 41 42 43 44
     0000        X    Dw    15                         0008 45 01 00 02 00 03 00 09
     0002        Y    Db    27                         0010 09 09 09 09 78 56 34 12
     0003        C    Db    'C'
     0004        Name Db    'ABCDE'
     0009        Z    Dw    1, 2, 3
     000F        A    Db    5 dup(9)
     0014        N    Dd    12345678h
     0018

Constant Definitions

• EQU - Same as C++ define.

 

    Max    equ    100        in Assembler is equivalent to C++:         #define   Max  100

 

• Decimal - Default numbers decimal representation.      Y  Dw  123
• Hexadecimal - Start with digit 0-9, append H to end.   Z  Dw  0BADH
• Binary - Use 0 or 1 and append B to end of number.     X  Db  01101001B

Internal Registers of Intel Processor (Important ones for now)

• eAX, eBX, eCX, eDX - 32 bit. Used for arithmetic.
• AX, BX, CX, DX - 16 bit. Used for arithmetic.
• AH, AL, BH, BL, CH, CL, DH, DL - 8-bit. The high H or low L half of the 16 bit register. The 8-bit AH AL combined is the 16-bit AX register, etc. For example, if AX=1234₁₆ then AH=12₁₆ and AL=34₁₆.

AX    AH    12    AL     34      1234

• eSP - 32-bit Stack Pointer. Points to the current top of stack. PUSH subtracts 4 from the SP and copies a 32-bit value onto the top of the stack, POP copies a 32-bit value from the top of the stack and adds 4 to SP.

Data Exchange

• MOV - Moves data between memory and registers. The source and destination must be the same size (byte or word).
• Copy 15 to the AL register -    Mov    AL, 15            AL=15
• Copy the eBX to eDX register -  Mov    eDX, eBX          eDX=eBX
• Copy variable Y above to CL -   Mov    CL, Y             CL=Y
• Copy BL to variable C above -   Mov    C, BL             C=BL
• PUSH - Subtracts 4 from the SP and copies a 32-bit value to the top of the stack.
• Copy eAX to top of stack -      Push    eAX
• Copy 1234 to top of stack -     Push    1234
• POP - Copies a 32-bit value from the top of the stack and adds 4 to SP.
• Copy value at stack top to eBx  Pop     eBx
• XCHG - Exchanges the values of the two operands,  8, 16, or 32-bit.
• Exchange AL and variable C -    XCHG    AL, C
• Exchange eAX and eDX registers  XCHG    eAX, eDX

Stack Operations (Push and Pop)

 

Pop

POP Operand effect is: Operand = [eSP] eSP = eSP + 4   Example Mov    eAx, 1234h     Address Stack Before Push     Stack After Pop Pop    eAx                   0008       0000           eSP-> 0000                     0006       0000           0000 eAX = 5678           eSP->   0004       5678                  5678                            0002       0000                  0000 Example Mov    eDx, 1234h           Address Stack Before      Stack After Push Mov    eBx, 5678h    eSP->   000C       0000                  0000 Push   eDx                   0008       0000                  1234 Push   eBx                   0004       0000           eSP->  5678                            0000       0000                  0000            Address Stack Before      Stack After Pop            000C       0000           eSP->  0000 Pop    eDx                   0008       1234                  1234 Pop    eBx           eSP->   0004       5678                  5678                     0000       0000                  0000 eDX = 5678 eBX = 1234

Addressing Modes

1. Immediate - Example: Mov eDX, 1234h, has 1234_x as the operand part of the instruction.
2. Register - Data source and destination are both registers within the CPU. Mov eDX, eBX, has eDX as the destination register and eBX as the source register.
3. Direct - One of the operands is a memory location. The instruction  Mov  U,  eAX, has one operand, U, a memory location. The instruction moves the contents of the eAX register value to a memory location,U.

Intel Register Set

eAX, eBX, eCX, eDX 32-bit general purpose registers (can be operands in most instructions, Add, Mov, Xchg, etc.) AX, BX, CX, DX - 16-bit general purpose registers (can be operands in most instructions, Add, Mov, Xchg, etc.). AH, AL, BH, BL, CH, CL, DH, DL - The corresponding high and low 8-bits of the AX, BX, CX, DX  registers. eSP - 32-bit stack pointer. eIP - Instruction pointer 32-bit, points to the next instruction to be fetched.

Physical Memory [16 bit, enrichment only]

Memory Addressing [16 bit, enrichment only]

1. program algorithm or code segment - CS
2. data segment - DS
3. stack segment - SS
4. extra segment - ES

To understand how segmented memory addressing works consider when a memory variable is accessed by the instruction, Mov X, 74h. Assume physical memory, the location of X in the segment, and the Ds register are defined as below. Remember that the DS register points to the start of the Data Segment where X is located. The offset of X is the distance of the location of X from the start of the segment.
 

• Segment - A segment is 64K of memory (65536 bytes) starting at the physical address (20-bit address) stored in a segment register (CS, DS, ES, SS). When DS=1230h, the data segment starts at 12300h physical memory.
• Offset - The 16-bit offset of a variable is its distance from the start of the data segment. The offset of X is 0048h. If DS=1230h, the data segment starts at 12300h, X is offset from the start of the data segment by 0048h bytes, so X is located in physical memory at 12300h + 0048h = 12348h.
• DS - Defines the start of the data segment in physical memory.
• Data Segment Physical Address - The physical address of a data segment variable is computed by the CPU each time a variable is accessed. The physical address of X is computed by:
 

Physical Address X = Ds*10h + offset X = 1230h*10h + 0048h = 12300h + 0048h = 12348h

• Code Segment Physical Address - The Cs register points to the start of the Code or algorithm memory. For each instruction fetch the CPU computes the physical address by:

 

Physical Address of fetch = Cs*10h + Ip

• Stack Segment Physical Address - The Ss register points to the start of the Stack memory. For each Push or Pop the CPU computes the physical address by:

Physical Address Push or Pop = Ss*10h + Sp

Assembly Program Structure [16 bit, enrichment only]

Data    Segment
        Variable definitions
Data    Ends

Code    Segment
        Assume   CS:Code, DS:Data, SS: Sseg        ;; Associate CS with Code
                                                   ;; DS with Data, SS with Sseg
        Proc1    Proc    Far
                 Algorithm 
        Proc1    Endp

        Proc2    Proc    Far
                 Algorithm 
        Proc2    Endp

 Code   Ends

 Sseg   Segment  STACK
        Db 254 dup(?)    
 Sseg   Ends

 End     Proc2                                     ;; First instruction executed
                                                   ;; is Proc2

Address Accessing Operators and Instructions [16-bit, enrichment only]

   0000			DATA     Segment                    ;;Data Segment 
   0000 0064		 R        DW            100         ;; R = 23
   0002 0008	         S        DW             8          ;; S = 8 
   0004 0001		 T        DW             1          ;; T = 1 
   0006 0000		 U        DW             ?          ;; U is uninitialized
   0008		        DATA     Ends                       ;; End of segment DATA

   0000			ALGORITHM Segment                   ;;Algorithm Segment 
			        Assume   Cs:ALGORITHM, Ds:DATA, Ss:SSeg

   0000			HW1     Proc     Far                ;; Procedure HW1
   0000  BB ---- R	        Mov      Bx, Seg DATA       ;; Initialize DS register 
   0003  8E DB		        Mov      Ds, Bx             ;; to address of data segment

• Initializing DS - The instruction at line 13 copies the starting location of the segment where the DATA for the program (i.e. variables R, S, T and U) has been loaded in physical memory. Bx is used as an intermediary because it is illegal to perform immediate addressing on Ds or other segment registers. The value in Bx is then copied to Ds. Until these two instructions are executed, the CPU uses whatever randomly happens to be in Ds as the data segment. That often explains why strange values may appear in the data when using the debugger until these two instructions are executed.
• Assume - Associates the segment registers with segment definitions. Normally the DS register is associated with the program data, the SS with the stack, etc. There is nothing to prevent us from specifying:
                    

Assume DS:Sseg, SS:Data

but the initialized Ss segment register would be used by stack operations Push and Pop. Note that the Assume does not initialize the segment registers so the Mov DS, Bx is needed to initialize DS to some known value.