CS255 Syllabus

The ADD and SUBTRACT instructions

The add instruction

The add instruction:

The add instruction of the M68000 CPU uses the 2's complement code
The add instruction will add 2 bit (binary number) patterns using the rules of the 2's complement code (that we have studied before)

Example of 2's complement code addtition:

11111111 (= -1₁₀) + 00000010 (= 2₁₀) ------------ 00000001 (= 1₁₀)

There are 2 add operations in M68000:

Add operation that uses a data register as destination register

The destination of an operation is used to store to result of the operation
So the result of the addition in this case is stored in a data register

The nmemonic for this add operation is:

ADD

Add operation that uses an address register as destination register

The destination of an operation is used to store to result of the operation
So the result of the addition in this case is stored in an address register

The nmemonic for this add operation is:

ADDA (The trailing A stands for Address register)

ADD: add operation that uses a data register as destination register

There are 3 instruction that add into a data register:

1. ADD.B Src, Dn // Add the 8 bits 2's complement values in Dn + Src // and store the 8 bits sum in Dn 2. ADD.W Src, Dn // Add the 16 bits 2's complement values in Dn + Src // and store the 16 bits sum in Dn 3. ADD.L Src, Dn // Add the 32 bits 2's complement values in Dn + Src // and store the 32 bits sum in Dn

Effect:

The add instruction using a data register as destination register will use the specified data type in the operation

In other words:

ADD.B D0, D1 will: add the byte operands in D0 and D1 and store the byte result in D1 ADD.W D0, D1 will: add the short (= word) operands in D0 and D1 and store the short result in D1 ADD.L D0, D1 will: add the int (= long word) operands in D0 and D1 and store the int result in D1

Using the ADD instruction

The Src operand can be one of the following:

A integer cosntant

Example:

ADD.W #2, D0 or: ADD.W #k, D0

A integer value stored in a (data) register
Example:

A integer value stored in a (RAM) memory

Example:

ADD.W 2, D0 or: ADD.W k, D0

Important:

You must use your knowledge on the address mode (that you have learned previously) to obtain the operand !!!

Example of the ADD instruction using constant operands
- Example of ADD instruction using constants:
Example of the ADD instruction using operands in data registers
- Example of ADD instruction using values in a data register:

Example of the ADD instruction using operands in RAM memory

Recall how integer (= whole number) values are stored in (RAM) memory:
Recall also the order in which the bytes are stored:

Example 1: adding a short typed value using the different add instructions

Suppose we define a short typed variable x as follows:

x: dc.w 2 * A short variable containing the value 2

The memory will contain the following short representation:
How ADD.B work on a short typed memory variable:
Comment:

How ADD.W work on a short typed memory variable:

Comment:

ADD.W used on a short typed variable works correctly !!!
(We added 2 to -1 and obtained 1 as answer --- use only 16 bits in D0 in your interpretation !!!)

How ADD.L work on a short typed memory variable:
Comment:

Example 2: adding a int typed value using the different add instructions

Suppose we define a int typed variable x as follows:

x: dc.l 2 * A short variable containing the value 2

The memory will contain the following short representation:
How ADD.B work on a int typed memory variable:
Comment:
How ADD.W work on a int typed memory variable:
Comment:

How ADD.L work on a int typed memory variable:

Comment:

ADD.L used on a int typed variable works correctly !!!
(We added 2 to -1 and obtained 1 as answer --- we must use all 32 bits in D0 in your interpretation !!!)

Another ADD instruction

M68000 has another ADD instruction with the following syntax:

1. ADD.B Dn, Dst // Add the 8 bits 2's complement values in Dn + Dst // and store the 8 bits sum in destination Dst 2. ADD.W Dn, Dst // Add the 16 bits 2's complement values in Dn + Dst // and store the 16 bits sum in destination Dst 3. ADD.L Dn, Dst // Add the 32 bits 2's complement values in Dn + Dst // and store the 32 bits sum in destination Dst

Comment:

The ADD Dn, Dst instruction is similar to the ADD Src, Dn instruction
The difference is the M68000 CPU will store the result in the Dst operand (instead of storing the result in the data register Dn)

Default operand type

Fact:

Default operand type:

If you do not specify a .B or .W or .L in a M68000 operation, then:
In other words:

Case sensitivity

Fact:
Example:

Important fact:

The user defined labels are case sensitive !!!

Example:

Correct use of labels: add.l x, D0 ... x: ds.l 1
Incorrect use of labels: add.l X, D0 // X is not the same as x !!! ... x: ds.l 1

What happens inside the computer when it execute a Java arithmetic statement

Believe it or not:

A similar Java statement is translated into different machine instructions !!!!!
In other words, the Java statement:
can result in different assembler programs depending on:

Example 1: adding integer variables

int x, y, z; (We assumed x,y,z have been defined) z = x + y; In assembler code: move.l x,D0 * Get 32 bits representation of x in D0 move.l y,D1 * Get 32 bits representation of y in D1 add.l D0,D1 * Add the two 32 bits representations together * The sum is stored in D1 move.l D1,z * Store the 32 bits representation in z

Example 2: adding short variables

short x, y, z; (We assumed x,y,z have been defined) z = x + y; In assembler code: move.w x,D0 * Get 16 bits representation of x in D0 move.w y,D1 * Get 16 bits representation of y in D1 add.w D0,D1 * Add the two 16 bits representations together * The sum is stored in D1 (16 bits) move.w D1,z * Store the 16 bits representation in z

ADDA: Adding in an address register

Fact:

When the destination of the add instruction is an address register, the instruction nmemonic gets an a appended to the tail
When the destination is an address register, you can only use word size and long word size instructions

There are 2 instructions to add into an address register:

1. ADDA.W Src, An * Add the 16 bit value Src to the address reg An * I.e.: An = An + Src(16 bits) 2. ADDA.L Sec, An * Add the 32 bit value Src to the address reg An * I.e.: An = An + Src(32 bits)

How the ADDA instruction work:

Fact:
Therefore:

In other words:

1. ADDA.W Src, An * Add the short (16 bit) Src to the address reg An * I.e.: An = An + Src(16 bits) is executed as follows: Step 1: convert the short (16 bit) Src to an int (32 bits) Step 2: add the (converted) result to address register An
2. ADDA.L Sec, An * Add the int (32 bit) Src to the address reg An * I.e.: An = An + Src(32 bits) (We don't need to perform conversion, because the Src is an int) (We just add the int Src value to the address reg An)

The SUB machine instruction

Subtract in a data register:

SUB.B Src, Dn * Subtract the 8 bits values: Dn = Dn - Src SUB.W Src, Dn * Subtract the 16 bits values: Dn = Dn - Src SUB.L Src, Dn * Subtract the 32 bits values: Dn = Dn - Src

Note:

The subtract instruction is very similar to the add instruction
You can use the above examples to learn about the subtract instruction
The examples will work if you replace:

Subtract in an address register:

SUBA.W Src, An * Subtract the 16 bits values: An = An - Src SUBA.L Src, An * Subtract the 32 bits values: An = An - Src

Reminder: When to use data and address registers

Data registers:

Address registers:

When you access an array element or a field in a linked list: use address registers

Example:

    short B[10;         (We assumed array B have been defined)

    ===>   Get the value of  B[3]  into register D0

 In assembler code:

         /* =========================================================
            We want to access B[3]:
              ==> put base address in address register
            ========================================================= */
         movea.l  #B,A0      * A0 = base address of array B
                             * An address is 32 bits, so we use .l !!!

         /* =========================================================
            We put the values B[3]  in data register D0
            ========================================================= */
         move.w    6(A0),D0  * Get short (16 bits) variable B[3] into register D0    
 
                             * We use an address register A0 because the 
			     * indirect addressing mode 6(A0) NEEDS to use
			     * an address register

			     * We put the value into a data register D0
			     * because we want use the value in B[3] in computations !!!