byte (1 byte integer (whole number) representation for values between -127..128) short (2 byte integer (whole number) representation for values between -32767..32768) int (4 byte integer (whole number) representation)

We can represent the same value using integer representation of different sizes

The value 3 (three dots) is represented as follows: Using 1 byte (8 bits): 00000011 Using 2 bytes (16 bits): 0000000000000011 Using 4 bytes (32 bits): 00000000000000000000000000000011

The value -3 is represented as follows: Using 1 byte (8 bits): 11111101 Using 2 bytes (16 bits): 1111111111111101 Using 4 bytes (32 bits): 11111111111111111111111111111101

Conversion = a procedure to transform one kind of representation into another kind of representation such that: The value of that is represented by both representation are the same

Example:

00000011 is the representation of the value 3 in 8 bits If we convert the representaion into a 16 bit representation, the result is: 0000000000000011 (Because both representations represent the value 3 !!!)

If the value represented by the smaller representation is positive: Add a bunch of leading 0 digits to the smaller representation (The number of leading 0 digits is equal to the difference in size between the larger and the smaller representation) If the value represented by the smaller representation is negative: Add a bunch of leading 1 digits to the smaller representation (The number of leading 1 digits is equal to the difference in size between the larger and the smaller representation)

Coincidentally, the leading binary digit in a 2's complement representation is: 0 when the value represented is positive 1 when the value represented is negative

Let x be the leading digit in the binary (2's complement) representation To convert a smaller representation into a larger representation: Add a bunch of leading x bits to the smaller representation (The number of leading 1 digits is equal to the difference in size between the larger and the smaller representation)

Add a bunch of leading x bits to a smaller representation

is called:

Sign-bit extension or sign-extension for short....

Convert a smaller 2's complement representation into a larger 2's complement representation

EXT.W Dn Sign extend a BYTE (6 bits) 2's complement representation to a WORD (16 bits) 2's complement representation in Data Register Dn EXT.L Dn Sign extend a WORD (16 bits) 2's complement representation to a LONG WORD (32 bits) 2's complement representation in Data Register Dn

Note:

There is no instruction to convert a byte (8 bits) representation to a long (32 bits) representation. However, we can accomplish the conversion from a byte (8 bits) representation to a long (32 bits) representation in 2 steps: * We start with an 8 bit representation in register Dn EXT.W Dn * Now we have a 16 bit representation in Dn EXT.L Dn * Now we have a 32 bit representation in Dn

Examples:

(1) +----------+----------+----------+----------+ D0 = | 10101010 | 01010101 | 10101010 | 11111110 | +----------+----------+----------+----------+ ^^^^^^^^ This byte represents the value "-2" After "EXT.W D0", we will have: +----------+----------+----------+----------+ D0 = | 10101010 | 01010101 | 11111111 | 11111110 | +----------+----------+----------+----------+ ^^^^^^^^^^^^^^^^^^^ This WORD represents the (same) value "-2" ! (2) Continuing with the previous example: +----------+----------+----------+----------+ D0 = | 10101010 | 01010101 | 11111111 | 11111110 | +----------+----------+----------+----------+ ^^^^^^^^^^^^^^^^^^^ This WORD represents the value "-2" After "EXT.L D0", we will have: +----------+----------+----------+----------+ D0 = | 10101010 | 01010101 | 11111111 | 11111110 | +----------+----------+----------+----------+ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This LONG WORD represents the (same) value "-2" !

Converting a smaller 2's complement representation to a larger 2's complement representation is very straightforward

Most programming languages provide an automatic conversion feature from a smaller 2's complement representation to a larger 2's complement representation

byte ---> short ---> int ---> long

int i; short s; byte b; The Java COMPILER translating the following assignment statements in a high level language will **automatically** use "EXT" assembler instructions: s = b; ---> MOVE.B b, D0 EXT.W D0 MOVE.W D0, s i = s; ---> MOVE.W s, D0 EXT.L D0 MOVE.L D0, i i = b; ---> MOVE.B b, D0 EXT.W D0 * First convert to WORD EXT.L D0 * THEN convert to LONG WORD ! MOVE.L D0, i

It is not safe convert from a larger data type to a smaller type

Prime-directive: The value that is represented must be equal after the conversion Recall: The value 3 (three dots) is represented as follows: Using 1 byte (8 bits): 00000011 Using 2 bytes (16 bits): 0000000000000011 Using 4 bytes (32 bits): 00000000000000000000000000000011 The value -3 is represented as follows: Using 1 byte (8 bits): 11111101 Using 2 bytes (16 bits): 1111111111111101 Using 4 bytes (32 bits): 11111111111111111111111111111101 Procedure to convert from a larger data type (representation) to a smaller type (representation): Truncate some of the leading number of digit I.e.: we keep the trailling binary digits The number of binary digits to truncate is equal to the difference in size between the larger data type (representation) and the smaller type (representation)

short s; byte b; (1) s = 1; (Stored as: 0000000000000001 --- represents value 1) b = (byte) s; Jave will assign the lower 8 bits of s to b: b will contain the binary representation 00000001 which correctly represents the value 1 (2) s = -2; (Stored as: 1111111111111110 --- represents value -1) b = (byte) s; Jave will assign the lower 8 bits of s to b: b will contain the binary representation 11111110 which correctly represents the value -2

int i; short s; byte b; The Java COMPILER truncate the representaion **ONLY** if you **beg** for it: b = (byte) s; ----> move.w s, d0 move.b d0, b b = (byte) i; ----> move.l i, d0 move.b d0, b s = (short) i; ----> move.l i, d0 move.w d0, s

Example:

s = 129; (Stored as: 0000000100000001 --- represents value 129) b = (byte) s; Jave will assign the lower 8 bits of s to b: b will contain the binary representation 00000001 which represent the value 1 and not the orignal value 129

When a lower-precision type and a higher-precision type are used in an arithmetic operation, the lower-precision representation is converted to the higher-precision representation first before the arithmetic operation is performed

int i, j; i = i + j;

In assembler: (no conversion is needed !)

move.l i, d0 move.l j, d1 add.l d0,d1 move.l d1, i

int i; short s; i = i + s;

In assembler:

move.l i, d0 32 bits of d0 used to represent int move.w s, d1 16 bits of d1 used to represent short ext.l d1 same value is now represented by 32 bits in d1 add.l d0,d1 move.l d1, i

int i; short s; s = (short) (s + i); // Casting means danger !

In assembler:

move.l i, d0 32 bits of d0 used to represent int move.w s, d1 16 bits of d1 used to represent short ext.l d1 same value is now represented by 32 bits in d1 add.l d0,d1 sum is represented by 32 bits in d1 move.w d1, s Used only 16 bits in d1

The assignment statement: int i; short s; s = s + i; is a shortening conversion and it can result in error (overflow error) For this reason, Java will disallow the assignment without explicit casting: int i; short s; s = s + i; // Java will report error !!!

The (short) casting operation is to let you tell Java that you know it's dangerous and "please let me do it anyway".

Assembler programming is the most difficult way to program a computer It is assumed that assembler programmers know what they are doing..... Assembler programmers do not ask permission to do anything !!!

(If you dare to program in assembler, you should be man enough to take on the responsibility to know what to do... You are not in Kansas anymore (to quote Dorothy))

• ext.s - shows how to convert byte -> short, byte -> long, word -> long
• ext2.s - shows how to add: byte + word, byte + long, word + long