March 2006 Saeid Nooshabadi

Slides:



Advertisements
Similar presentations
Multiplication – Microprocessor
Advertisements

Integer Arithmetic: Multiply, Divide, and Bitwise Operations
1 ECE 5465 Advanced Microcomputers Group 11: Brian Knight Benjamin Moore Alex Williams.
Embedded System Design Center ARM7TDMI Microprocessor Data Processing Instructions Sai Kumar Devulapalli.
COMP3221 lec10-logical-II&mul.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 10: C/Assembler Logical and Shift – II & Multiplication.
COMP3221 lec9-logical-I.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 9: C/Assembler Logical and Shift - I
COMP3221 lec-12-mem-II.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 12: Memory Access - II
Binary Logic (review) Basic logical operators: (Chapter 7 expanded)
Computer Organization & Assembly Language
Modified from the notes by
COMP3211 lec22-fraction.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lectures 22 : Fractions September,
COMP3221 lec05-numbers-I.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 5: Number Systems – I
COMP3221 lec08-arith.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 8: C/Assembler Data Processing
Elec2041 lec-11-mem-I.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 4: Memory Access March,
COMP3221 lec06-numbers-II.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 6: Number Systems - II
Elec2041 lec-11-mem-I.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 11: Memory Access - I
Computer Architecture CPSC 321 E. J. Kim. Overview Logical Instructions Shifts.
Logical & shift ops (1) Fall 2007 Lecture 05: Logical Operations.
Lecture 5 Sept 14 Goals: Chapter 2 continued MIPS assembly language instruction formats translating c into MIPS - examples.
ECE 15B Computer Organization Spring 2010 Dmitri Strukov Lecture 6: Logic/Shift Instructions Partially adapted from Computer Organization and Design, 4.
COMP3221 lec07-numbers-III.1 Saeid Nooshabadi COMP 3221 Microprocessors and Embedded Systems Lecture 7: Number Systems - III
ARM Instructions I Prof. Taeweon Suh Computer Science Education Korea University.
Embedded System Design Center Sai Kumar Devulapalli ARM7TDMI Microprocessor Thumb Instruction Set.
Topic 8: Data Transfer Instructions CSE 30: Computer Organization and Systems Programming Winter 2010 Prof. Ryan Kastner Dept. of Computer Science and.
07/19/2005 Arithmetic / Logic Unit – ALU Design Presentation F CSE : Introduction to Computer Architecture Slides by Gojko Babić.
Lecture 6: Multiply, Shift, and Divide
ICS312 Set 9 Logic & Shift Instructions. Logic & Shift Instructions Logic and Shift Instructions can be used to change the bit values in an operand. The.
BITWISE OPERATIONS – Microprocessor Asst. Prof. Dr. Choopan Rattanapoka and Asst. Prof. Dr. Suphot Chunwiphat.
Lecture 2: Advanced Instructions, Control, and Branching EEN 312: Processors: Hardware, Software, and Interfacing Department of Electrical and Computer.
ARM Shifts, Multiplies & Divide??. MVN Pseudo Instructions Pseudo Intruction: Supported by assembler, not be hardware.
Binary Logic (review) Basic logical operators:(Chapter 7 expanded) NOT AND – outputs 1 only if both inputs are 1 OR – outputs 1 if at lest one input is.
Chapter 4 Operations on Bits.
Chapter 15: Higher Level Constructs
Integer Multiplication and Division
Chapter 5 Integer Arithmetic.
ARM Registers Register – internal CPU hardware device that stores binary data; can be accessed much more rapidly than a location in RAM ARM has.
Morgan Kaufmann Publishers
Instructor: David Ferry
Binary Arithmetic Binary arithmetic is essential in all digital computers and in many other types of digital systems. Addition, Subtraction, Multiplication,
Number Systems Give qualifications of instructors:
Digital Systems Section 8 Multiplexers. Digital Systems Section 8 Multiplexers.
March 2006 Saeid Nooshabadi
Multiplication and Division Instructions
ECE 3430 – Intro to Microcomputer Systems
March 2006 Saeid Nooshabadi
The University of Adelaide, School of Computer Science
Morgan Kaufmann Publishers Computer Organization and Assembly Language
Topic 3c Integer Multiply and Divide
Computer Architecture & Operations I
Topic 6: Bitwise Instructions
Shift & Rotate Instructions)
Digital Systems Section 12 Binary Adders. Digital Systems Section 12 Binary Adders.
Multiplication by small constants (pp. 139 – 140)
Computer Architecture
Arithmetic and Logic Chapter 5
Table 3‑1: Unsigned Data Range Summary in ARM
The ARM Instruction Set
ELEC Microprocessors and Interfacing Lectures 22: Fractions May 2006
March 2006 Saeid Nooshabadi
Branching instructions
March 2006 Saeid Nooshabadi
Overheads for Computers as Components 2nd ed.
March 2006 Saeid Nooshabadi
Multiplication and Division Instructions
Multiplication and Division Instructions
Multiply Instructions
Immediate data Immediate operands : ADD r3, r3, #1 valid ADD r3, #1,#2 invalid ADD #3, r1,r2 invalid ADD r3, r2, #&FF ( to represent hexadecimal immediate.
MICROCONTROLLERS AND EMBEDDED SYSTEMS Unit – 4 : ARM / Thumb Instruction set GEC
Chapter 10 Instruction Sets: Characteristics and Functions
Arithmetic and Logic Chapter 3
Presentation transcript:

March 2006 Saeid Nooshabadi saeid@unsw.edu.au ELEC2041 Microprocessors and Interfacing Lecture 10: C/Assembler Logical and Shift – II & Multiplication http://webct.edtec.unsw.edu.au/ March 2006 Saeid Nooshabadi saeid@unsw.edu.au

Overview Shift Operations Multiplication Operations Field Insertion Long Multiplication Multiplication and accumulation Signed and unsigned multiplications credential: bring a computer die photo wafer : This can be an hidden slide. I just want to use this to do my own planning. I have rearranged Culler’s lecture slides slightly and add more slides. This covers everything he covers in his first lecture (and more) but may We will save the fun part, “ Levels of Organization,” at the end (so student can stay awake): I will show the internal stricture of the SS10/20. Notes to Patterson: You may want to edit the slides in your section or add extra slides to taylor your needs.

Review: ARM Instructions So far add sub mov and bic orr eor Data Processing Instructions with shift and rotate lsl, lsr, asr, ror

Review: Masking via Logical AND AND:Note that anding a bit with 0 produces a 0 at the output while anding a bit with 1 produces the original bit. This can be used to create a mask. Example: 1011 0110 1010 0100 0011 1101 1001 1010 0000 0000 0000 0000 0000 0000 1111 1111 The result of anding these two is: 0000 0000 0000 0000 0000 0000 1001 1010 Mask:

Review: Masking via Logical BIC BIC (AND NOT):Note that bicing a bit with 1 produces a 0 at the output while bicing a bit with 0 produces the original bit. This can be used to create a mask. Example: 1011 0110 1010 0100 0011 1101 1001 1010 0000 0000 0000 0000 0000 0000 1111 1111 The result of bicing these two is: 1011 0110 1010 0100 0011 1101 0000 0000 Mask:

Extracting a field of bits (#1/2) Extract bit field from bit 9 (left bit no.) to bit 2 (size=8 bits) of register v1, place in rightmost part of register a1 1 2 3 4 5 6 7 8 9 31 v1 a1 Shift field as far left as possible (9 31) and then as far right as possible (317) v1 a1 a1

Extracting a field of bits (#2/2) mov a1, v1, lsl #22 ;8 bits to left end (31-9) a1 v1 mov a1, a1, lsr #24 ;8 bits to right end(7-0) a1

Inserting a field of bits Insert bit field into bit 9 (left bit no.) to bit 2 (size=8 bits) of register a1 from rightmost part of register v1 (rest is 0) 1 2 3 4 5 6 7 8 9 31 v1 a1 Shift left field 2 bits, Mask out field, OR in field a2=v1<<2 a1 masked a1 ored a2 mov a2, v1, lsl #2 ; field left 2 bic a1, a1, #0x3FC ; mask out 9-2 ; 0x03FC = 0011 1111 1100 orr a1, a1, a2 ; OR in field ; bic stands for ‘bit clear, where ‘1’ in the second operand clears ; the corresponding bit in the first

Bit manipulation in C (#1/2) Convert C code to ARM ASM Bit Fields in C (Word as 32 bits vs int/unsigned!) struct { unsigned int ready: 1; /* bit 0 */ unsigned int enable: 1; /* bit 1 */ } rec; rec.enable = 1; rec.ready = 0; printf(“%d %d“, rec.enable, rec.ready); ... rec 1 31 enable ready Brian Kernighan & Dennis Ritchie: The C Programming Language, 2nd Ed., PP 150

Bit manipulation in C (#2/2) struct { unsigned int ready: 1; /* bit 0 */ unsigned int enable: 1; /* bit 1 */ } rec; /* v1 */ rec.enable = 1; rec.ready = 0; printf(“%d %d“, rec.enable, rec.ready); 1 orr v1,v1, #0x2 ;1 in bit 1 bic v1,v1 #1 ;0 in bit 0, rec 1 31 enable ready ldr a1, =LCO ;printf format mov a2, v1, lsr #1 ;just bit 1 and a2, a2,0x0001 ;mask down to 1 and a3, v1, 0x0001 ;just bit 0 bl printf ;call printf

Multiply by Power of 2 via Shift Left (#1/3) In decimal: Multiplying by 10 is same as shifting left by 1: 71410 x 1010 = 714010 5610 x 1010 = 56010 Multiplying by 100 is same as shifting left by 2: 71410 x 10010 = 7140010 5610 x 10010 = 560010 Multiplying by 10n is same as shifting left by n

Multiply by Power of 2 via Shift Left (#2/3) In binary: Multiplying by 2 is same as shifting left by 1: 112 x 102 = 1102 10102 x 102 = 101002 Multiplying by 4 is same as shifting left by 2: 112 x 1002 = 11002 10102 x 1002 = 1010002 Multiplying by 2n is same as shifting left by n

Multiply by Power of 2 via Shift Left (#3/3) Since shifting is so much faster than multiplication (you can imagine how complicated multiplication is), a good compiler usually notices when C code multiplies by a power of 2 and compiles it to a shift instruction: a *= 8; (in C) would compile to: mov a0,a0,lsl #3 (in ARM) Operand 1 Result ALU Barrel Shifter Operand 2

Shift, Add and Subtract for Multiplication Add and Subtract Examples: f = 5*g /* f = (4+1) x g */ (in C) add v1,v2,v2 lsl #2 ; v1 = v2 + v2 *4 (in ARM) f = 105 *g /* f = (15 x 7) x g */ (in C) /* f = (16 –1 ) x (8 – 1) x g */ rsb v1,v2,v2 lsl #4 ; v1 = -v2 + v2 *16 (in ARM) ; f = (16-1)* g rsb v1,v1,v1 lsl #3 ; v1 = -v1 + v1 *8 (in ARM) ; f = (8-1)* f

Shift, Add and Subtract for Division ARM does not have division. Division A/B produces a quotient and a remainder. It should be done via sequence of subtraction and shifting (See Experiment 3) For B in A/B a constant value (eg 10) simpler technique via Shift, Add and Subtract is available (Will be discussed later)

Shift Right Arithmetic; Divide by 2??? Shifting left by n is same as Multiplying by 2n Shifting right by n bits would seem to be the same as dividing by 2n Problem is signed integers Zero fill is wrong for negative numbers Shift Right Arithmetic (asr); sign extends (replicates sign bit); 1111 1111 1111 1000 = -8 1111 1111 1111 1100 = -4 1111 1111 1111 1110 = -2 1111 1111 1111 1111 = -1

Is asr really divide by 2? Divide +5 by 4 via asr 2; result should be 1 0000 0000 0000 0000 0000 0000 0000 0101 0000 0000 0000 0000 0000 0000 0000 0001 = +1, so does work Divide -5 by 4 via asr 2; result should be -1 1111 1111 1111 1111 1111 1111 1111 1011 1111 1111 1111 1111 1111 1111 1111 1110 = -2, not -1; Off by 1, so doesn’t always work Rounds to –

MULTIPLY (unsigned): Terms, Example Paper and pencil example (unsigned): Multiplicand 1000 Multiplier 1001 1000 0000 0000 1000 Product 01001000 + m bits x n bits = m+n bit product 32-bit value x 32-bit value = 64-bit value

MULTIPLY (signed)? #(1/3) Paper and pencil example Multiplicand 1000 -8 x Multiplier 1001 -7 1000 0000 0000 1000 Product 01001000 72  56 + Solution 1: 2’s complement range for 4 bit number is –8 a 7  – 56  a x b  64. Can build a big lookup table (16 x 16 = 256) to map from binary bit patterns to multiplication results. -8 x –8 = 01000000   64 -8 x –7 = 01001000   56 | -2 x –2 = 11000100   04 -1 x -1 = 11100001   01 +7 x +7 = 00110001   49

MULTIPLY (signed)? #(2/3) Solution 2: Multiplicand 1001 -7 x Multiplier 1000 -8 00000000 0000000 000000 11001 Product 00111000 56 = 56 + – Multiplicand 1001 -7 x Multiplier 1000 -8 00000000 0000000 000000 00111 Product 00111000 56 = 56 +

MULTIPLY (signed)? #(3/3) Solution 2 (Another example): Multiplicand 1001 -7 x Multiplier 1001 -7 11111001 0000000 000000 11001 Product 00110001 49 = 49 + – Multiplicand 1001 -7 x Multiplier 1000 -7 11111001 0000000 000000 00111 Product 00110001 49 = 49 +

Multiplication Instructions The Basic ARM provides two multiplication instructions. Multiply mul Rd, Rm, Rs ; Rd = Rm * Rs Multiply Accumulate - does addition for free mla Rd, Rm, Rs,Rn ; Rd = (Rm * Rs) + Rn (Lower precision multiply instructions simply throws top 32bits away) Restrictions on use: Rd and Rm cannot be the same register Can be avoided by swapping Rm and Rs around. This works because multiplication is commutative. Cannot use PC. These will be picked up by the assembler if overlooked. Operands can be considered signed or unsigned Up to user to interpret correctly. One example of use of MLA is for string to number conversion: eg/ Convert string=“123” to value=123 value = 0 loop = 0 len = length of string while loop <> len c = extract( string, len -loop,1) Rm = 10 ^ loop Rs = ASC(c) - ASC (‘0’) Rd = value MLA Rd, Rm, Rs, Rd loop = loop + 1 endwhile

Multiplication Example in C: a = b * c; in ARM: let b be v1; let c be v2; and let a be v3 (It may be up to 64 bits) mul v3, v2, v1 ;a = b*c ; lower half of product into ; v3. Upper half is thrown up Note: Often, we only care about the lower half of the product.

Multiplication and Accumulate Example One example of use of mla is for string to number conversion: eg Convert string=“123” to value=123 value = 0 loop = 0 len = length of string Rd = value while loop <> len c = extract(string, len - loop,1) Rm = 10 ^ loop Rs = ASC(c) - ASC (‘0’) mla Rd, Rm, Rs, Rd loop = loop + 1 endwhile

Multiply-Long and Multiply-Accumulate Long Instructions are MULL which gives RdHi,RdLo:=Rm*Rs MLAL which gives RdHi,RdLo:=(Rm*Rs)+RdHi,RdLo However the full 64 bit of the result now matter (lower precision multiply instructions simply throws top 32 bits away) Need to specify whether operands are signed or unsigned Therefore syntax of new instructions are: umull RdLo,RdHi,Rm,Rs ;RdHi,RdLo:=Rm*Rs umlal RdLo,RdHi,Rm,Rs ;RdHi,RdLo:=(Rm*Rs)+RdHi,RdLo smull RdLo, RdHi, Rm, Rs ;RdHi,RdLo:=Rm*Rs (Signed) smlal RdLo, RdHi, Rm, Rs ;RdHi,RdLo:=(Rm*Rs)+RdHi,RdLo (Signed) Not generated by some compilers. (Needs Hand coding) Restrictions - will be picked up by the assembler if overlooked: RdHi, RdLo and Rm, and combinations of, cannot be same register. r15 cannot be used.

Division No Division Instruction in ARM Division has two be done in software through a sequence of shift/ subtract / add instruction. General A/B implementation (See Experiment 3) For B in A/B a constant value (eg 10) simpler technique via Shift, Add and Subtract is available (Will be discussed later)

Quiz 1. Specify instructions which will implement the following: a) a1 = 16 b) a2 = a1 * 4 c) a1 = a2 / 16 ( r1 signed 2's comp.) d) a2 = a3 * 7 2. What will the following instructions do? a) add a1, a2, a2, lsl #2 b) rsb a3, a2, #0 3. What does the following instruction sequence do? add a1, a2, a2, lsl #1 sub a1, a1, a2, lsl #4 add a1, a1, a2, lsl #7 1a/ MOV r0, #16 1b/ MOV r1, r0, LSL #2 (or MUL r1, r0, r2 - where r2 = 4) 1c/ MOV r0, r1, ASR#4 (preserves sign bit whereas LSR puts 0’s in) 1d/ r2*7 = (r2*8) - r2 RSB r1, r2, r2, LSL #3 [whereas SUB r1, r2, r2, LSL#3 would give r2* -7] 2a/ r0= r1+ (r1 * 4) ie r0:=r1*5 and S means update condition flags 2b/ r2=0-r1 ie r2:= -r1 3/ r0 = r1 + (r1 * 2) = r1 * 3 r0 = r0 - (r1 * 16) = (r1 * 3) - (r1 * 16) = r1 * -13 r0 = r0 + (r1 * 128) = (r1 * -13) + (r1 * 128) = r1 * 115 i.e. r0 = r1 * 115

Quiz Solution (#1/2) 1. Specify instructions which will implement the following: a1 = 16 mov a1, #16 a2 = a1 * 4 mov a2, a1, lsl #2 a1 = a2 / 16 ( r1 signed 2's comp.) mov a1, a2, asr #4 a2 = a3 * 7 rsb a2, a3, a3, lsl #3 a2 = a3* (8-1) whereas sub a2, a3, a3, lsl #3 would give a3* -7 2. What will the following instructions do? add a1, a2, a2, lsl #2 a1= a2 + (a2 * 4) ie a1:=a2*5 b) rsb a3, a2, #0 r2=0-r1 ie r2:= -r1 1a/ MOV r0, #16 1b/ MOV r1, r0, LSL #2 (or MUL r1, r0, r2 - where r2 = 4) 1c/ MOV r0, r1, ASR#4 (preserves sign bit whereas LSR puts 0’s in) 1d/ r2*7 = (r2*8) - r2 RSB r1, r2, r2, LSL #3 [whereas SUB r1, r2, r2, LSL#3 would give r2* -7] 2a/ r0= r1+ (r1 * 4) ie r0:=r1*5 and S means update condition flags 2b/ r2=0-r1 ie r2:= -r1 3/ r0 = r1 + (r1 * 2) = r1 * 3 r0 = r0 - (r1 * 16) = (r1 * 3) - (r1 * 16) = r1 * -13 r0 = r0 + (r1 * 128) = (r1 * -13) + (r1 * 128) = r1 * 115 i.e. r0 = r1 * 115

Quiz Solution (#2/2) 3. What does the following instruction sequence do? add a1, a2, a2, lsl #1 sub a1, a1, a2, lsl #4 add a1, a1, a2, lsl #7 a1 = a2 + (a2 * 2) = a2 * 3 a1 = a1 - (a2 * 16)= (a2 * 3) - (a2 * 16) = a2 * -13 a1 = a1 + (a2 * 128) = (a2 * -13) + (a2 * 128) = r1 * 115 i.e. a1 = a2 * 115 1a/ MOV r0, #16 1b/ MOV r1, r0, LSL #2 (or MUL r1, r0, r2 - where r2 = 4) 1c/ MOV r0, r1, ASR#4 (preserves sign bit whereas LSR puts 0’s in) 1d/ r2*7 = (r2*8) - r2 RSB r1, r2, r2, LSL #3 [whereas SUB r1, r2, r2, LSL#3 would give r2* -7] 2a/ r0= r1+ (r1 * 4) ie r0:=r1*5 and S means update condition flags 2b/ r2=0-r1 ie r2:= -r1 3/ r0 = r1 + (r1 * 2) = r1 * 3 r0 = r0 - (r1 * 16) = (r1 * 3) - (r1 * 16) = r1 * -13 r0 = r0 + (r1 * 128) = (r1 * -13) + (r1 * 128) = r1 * 115 i.e. r0 = r1 * 115

ELEC2041 Reading Materials (Week #4) Week #4: Steve Furber: ARM System On-Chip; 2nd Ed, Addison-Wesley, 2000, ISBN: 0-201-67519-6. We use chapters 3 and 5 ARM Architecture Reference Manual –On CD ROM

“And in Conclusion…” New Instructions: mul mla umull umlal smull smlal