1. Natawut NupairojAssembly Language1 Arithmetic Operations

2. Natawut NupairojAssembly Language2 Arithmetic Operations Signed/unsigned integer –64-bit –96-bit (extended precision) Floating-point –32-bit (single precision) –64-bit (double precision) –128-bit (quadraple precision) 64-bit logical operations

3. Natawut NupairojAssembly Language3 Integer Operations Signed Integer –[-2 (n-1), 2 (n-1) -1] Unsigned Integer –[0, 2 n -1] Indentical Operations: add, sub,... Difference in how to interpret condition codes and branches add, addcc*, sub, subcc* Format: add rs, reg_or_imm, rd

4. Natawut NupairojAssembly Language4 Condition Codes V - set when the register is not long enough to hold the result. N - set when the most significant bit is 1. C - set when the operation generates a carry. Z - set when all bits of the result are zero.

5. Natawut NupairojAssembly Language5 Constants Representations Integer mov 97, %r1! Decimal number mov 0141, %r1! Octal number mov 0x61, %r1! Hexadecimal number Character mov 'a', %r1 mov "a", %r1 ASCII table

6. Natawut NupairojAssembly Language6 Integer Example do { x--;/* x = x - 1; */ } while(x != 0) Approach#1 loop: sub %l0, 1, %l0 cmp %l0, 0 bne loop nop Approach#2 loop: subcc %l0, 1, %l0 bnz loop nop

7. Natawut NupairojAssembly Language7 Logical Operations and, andn, xor, or, xnor, orn andce, andncc, xorcc, orcc, xnorcc, orncc not a andn b= a and (not b) a xnor b= a xor (not b) a orn b= a or (not b)

8. Natawut NupairojAssembly Language8 Logical Example SPARC Logical0 0 1 1a Instr. Operations0 1 0 1b anda and b0 0 0 1 andna and (not b)0 0 1 0 or a or b0 1 1 1 orna or (not b)1 0 1 1 xora xor b0 1 1 0 xnora xor (not b)1 0 0 1

9. Natawut NupairojAssembly Language9 Shift Operations There are 3 shift instructions:

10. Natawut NupairojAssembly Language10 Shift Examples mov 1, %l1! %l1 = 00 00 00 00000001 sll %l1, 4, %l2! %l2 = 00 00 00 00010000 srl %l2, %l1, %l3! %l3 = 00 00 00 00001000 sll %l1, 31, %l2! %l2 = 10000000 00 00 00 sra %l2, 3, %l3! %l3 = 11110000 00 00 00 srl %l2, 3, %l3! %l3 = 00010000 00 00 00

11. Natawut NupairojAssembly Language11 Our Third Program Convert pack decimal number in “x” (8 digits, no sign) to be stored in “y” in binary format. Example: –convert pack-decimal “12345678” to binary. Pack-decimal: –0001 0010 0011 0100 0101 0110 0111 1000 Binary: –0000 0000 1011 1100 0110 0001 0100 1110 –two approaches from left to right or from right to left. –We will do from right to left.

12. Natawut NupairojAssembly Language12 Our Third Program First, extract the rightmost digit. Then, multiply it with 10^(digit-1) and add it to the result. Shift x to right 4 times to get the next digit. Repeat until all digits are done. For example: to convert “12345678”. 8*10^(1-1) + 7*10^(2-1) + … + 1*10^(8-1) = 12345678 We will need a variable to keep track the value to multiply to each digit.

13. Natawut NupairojAssembly Language13 Our Third Program int main() { int x, y, num, i, mulval; x = 0x12345678;// number to be converted. y = 0;// result. mulval = 1;// 10^(digit-1). for(i=0 ; i < 8 ; i++) { num = x & 0xF;// extract the rightmost digit. y = y + num*mulval;// add to the result. x = x >> 4;// next digit. mulval = mulval * 10; }

14. Natawut NupairojAssembly Language14 Our Third Program define(x_r, l0) define(y_r, l1) define(i_r, l2) define(mulval_r, l3) define(num_r, l4).global main main:save %sp, -64, %sp set 0x12345678, %x_r !load 32-bit constant to x clr %y_r! y = 0; mov 1, %mulval_r! mulval = 1;

15. Natawut NupairojAssembly Language15 Our Third Program ! Convert for to while loop clr %i_r! i = 0; loop:cmp %i_r, 8! if i >= 8 bge done! then exit the loop nop! delay slot and %x_r, 0xF, %num_r! num = x & 0xF; mov %num_r, %o0 mov %mulval_r, %o1 call.mul! num * mulval nop! delay slot add %y_r, %o0, %y_r! y = y + num*mulval; srl %x_r, 4, %x_r! x = x >> 4;

16. Natawut NupairojAssembly Language16 Our Third Program mov %mulval_r, %o0 mov 10, %o1 call.mul ! mulval*10 nop ! delay slot mov %o0, %mulval_r ! mulval = mulval*10; add %i_r, 1, %i_r ! i++; ba loop ! repeat loop nop ! delay slot done:mov 1, %g1 ! end of program ta 0

17. Natawut NupairojAssembly Language17 Synthetic Instructions using %g0 "cmp" is actually a synthetic instruction. –This instruction is not existed !!! –But it got translated to something else !!! cmp %r1, 12 = subcc %r1, 12, %g0 For example: –to compare %r1 and 12, first sub %r1 with 12. –if result = 0, %r1 = 12. (Z = 1) –If result < 0, %r1 < 12. (N = 1) –If result > 0, %r1 > 12. (N = 0)

18. Natawut NupairojAssembly Language18 Comparison and Condition Codes Instruction be bne bl bg ble bge Condition Codes Z = 1 Z = 0 (N xor V) = 1 (N xor V) = 0 (Z or (N xor V)) = 1 (Z or (N xor V)) = 0

19. Natawut NupairojAssembly Language19 Other Synthetic Instructions mov 201, %o2 = or %g0, 201, %o2 mov %g5, %i6 = or %g0, %g5, %g6 clr %i7 = or %g0, %g0, %i7 tst %l6 = subcc %l6, %g0, %g0

20. Natawut NupairojAssembly Language20 Set 32-bit Constant to Register set 0x12345678, %l2 For any instruction, the biggest (or smallest) constant value is 4095 (or -4096) which is a 22- bit constant. (Why?) For 32-bit constant, we use the “set” instruction which is a synthetic instruction. It is converted to: sethi %hi(0x12345678), %l2 or %l2, %lo(0x12345678), %l2

21. Natawut NupairojAssembly Language21 Set 32-bit Constant to Register 0001 0010 0011 0100 0101 0110 0111 1000 sethi %hi(0x12345678), %l2 Store the first 22-bit of the constant to %l2. or %l2, %lo(0x12345678), %l2 Store the last 10-bit of the constant to %l2. Done by assembler*