Transcript Slide 1

Lecture 2: Advanced
Instructions, Control, and
Branching
EEN 312: Processors:
Hardware, Software, and
Interfacing
Department of Electrical and Computer Engineering
Spring 2014, Dr. Rozier (UM)
COURSE PLAN FOR TODAY
1. Representing Numbers
2. Logical Operations
3. Control Instructions
REPRESENTING NUMBERS
Unsigned Binary Integers
• Given an n-bit number
n1
x  xn12


 xn2 2
  x12  x0 2
1
0
Range: 0 to +2n – 1
Example


n2
0000 0000 0000 0000 0000 0000 0000 10112
= 0 + … + 1×23 + 0×22 +1×21 +1×20
= 0 + … + 8 + 0 + 2 + 1 = 1110
Using 32 bits

0 to +4,294,967,295
2s-Complement Signed Integers
• Given an n-bit number
n1
x  xn12


 xn2 2
  x12  x0 2
1
0
Range: –2n – 1 to +2n – 1 – 1
Example


n2
1111 1111 1111 1111 1111 1111 1111 11002
= –1×231 + 1×230 + … + 1×22 +0×21 +0×20
= –2,147,483,648 + 2,147,483,644 = –410
Using 32 bits

–2,147,483,648 to +2,147,483,647
2s-Complement Signed Integers
• Bit 31 is sign bit
– 1 for negative numbers
– 0 for non-negative numbers
• –(–2n – 1) can’t be represented
• Non-negative numbers have the same unsigned and
2s-complement representation
• Some specific numbers
–
–
–
–
0: 0000 0000 … 0000
–1: 1111 1111 … 1111
Most-negative: 1000 0000 … 0000
Most-positive: 0111 1111 … 1111
2s-Complement Signed Integers
• Complement and add 1
– Complement means 1 → 0, 0 → 1
x  x  1111...1112  1
x  1  x

Example: negate +2


+2 = 0000 0000 … 00102
–2 = 1111 1111 … 11012 + 1
= 1111 1111 … 11102
Hexadecimal
• Base 16
– Compact representation of bit strings
– 4 bits per hex digit
0
1
2
3

0000
0001
0010
0011
4
5
6
7
0100
0101
0110
0111
8
9
a
b
1000
1001
1010
1011
c
d
e
f
1100
1101
1110
1111
Example: eca8 6420

1110 1100 1010 1000 0110 0100 0010 0000
LOGICAL OPERATIONS
Bitwise Operations
• Sometimes we want to operate on registers in
a bitwise fashion.
• Logical Operations
• Shifts
• Rotates
Logical Operations
• Instructions for bitwise manipulation
Operation
C
Java
ARM
Bitwise AND
&
&
and
Bitwise OR
|
|
orr
Bitwise XOR
^
^
eor
Bitwise NAND
~(A & B)
~(A&B)
bic
Example
bic r0, r1, r2 @ bitwise NAND r1 and r2, store
the result in r0
The ARM Barrel Shifter
• ARM architectures have a unique piece of
hardware known as a barrel shifter.
– Device moves bits in a word left or right.
• Most processors have stand alone instructions
for shifting bits.
• ARM allows shifts as part of regular
instructions.
• Allows for quick multiplication and division.
The ARM Barrel Shifter
The ARM Barrel Shifter
• Reality of the hardware
– There are no shift
instructions
– Barrel shifter can be
controlled WITH an
instruction
– Can only be applied to
operand 2 on
instructions which use
the ALU
Types of Shifting
• Logical Shifts
– lsl – left
– lsr – right
• Arithmetic Shifts
– asr – right
• Rotates
– ror – right
– rrx – right with extend
Example
mov r0, r1, lsl #1
This would perform a logical shift left of 1 bit on
r1, and then copy the result into r0.
mov r0, r1, lsl r2
This would do the same as before, but use the
value of r2 for the shift amount.
Logical Shifts
• Logical shifting a number left or right has the
effect of doubling or halving it.
LSL
C
b7
b6
b5
b4
b3
b2
b1
b0
Before 0
1
0
0
0
1
1
1
1
After
0
0
0
1
1
1
1
0
1
• lsl
– Highest order bit shifts into the carry flag
– Lowest order bit is filled with 0.
• lsr
– Lowest order bit shifts into the carry flag
– Highest order bit is filled with 0.
Arithmetic Shift
• Preserves the sign bit.
LSL
C
b7
b6
b5
b4
b3
b2
b1
b0
Before 0
1
0
0
0
1
1
1
1
After
1
1
0
0
0
1
1
1
1
• asr
– Extends the sign bit to the second most significant
– Shifts the least significant into the carry flag.
Rotations
• Rotates bits from low order to high order
LSL
C
b7
b6
b5
b4
b3
b2
b1
b0
Before 0
0
0
0
0
1
1
1
1
After
1
0
0
0
0
1
1
1
1
• ror
– Moves bits from the lowest order to the highest, setting the carry bit
in the process with the last bit rotated out.
• rrx
– Always and only rotates by one position.
– Carry flag is dropped into the highest order bit. Lowest order bit is
moved to the carry flag
Rotations
• ror
• rrx
Adding a Shift or Rotate
• Shifts and rotates can be used with:
– adc, add, and
– bic
– cmn, cmp
– eor
– mov, mvn
– orr
– rsb
– sbc, sub
– teq, tst
BRANCHING
Branching
• What makes a computer different from a
calculator?
Branching
• Branches allow us to transfer control of the
program to a new address.
– b (<suffix>) <label>
– bl (<suffix>) <label>
b start
bl start
Branch (b)
• Branch, possibly conditionally, to a new
address.
beq subroutine @ If Z=1, branch
• Good practice to use bal instead of b.
Branch with link (bl)
• Branch, possibly conditionally, to a new
address.
– Before the branch is complete, store the PC in the
LR.
– Allows easy return from the branch.
bleq subroutine @ If Z=1, branch, saving the PC
Branch with link (bl)
• How do we get back once we’ve saved the PC?
mov pc, lr
• Moves the contents of the link register to the
program counter.
Implementing If Statements
• C code:
if (i == j) f = g+h;
else f = g - h;
• ARM code
cmp r0, r1 @ Set flags via r0-r1 and discard
beq Else
add r2, r3, r4 @ r2 = r3 + r4
bal Exit
Else:
sub r2, r3, r4 @ r2 = r3 + r4
Exit:
Implementing Loop Statements
• C code:
while (i < j) i += 1;
• ARM code
Loop:
i<j
i>=j
cmp r0, r1
bge Exit
add r0, r0, #1
bal Loop
Exit:
i < j?
i=i+1
Exit
Basic Blocks
• A basic block is a sequence of instructions with
– No embedded branches (except at end)
– No branch targets (except at beginning)


A compiler identifies basic
blocks for optimization
An advanced processor
can accelerate execution
of basic blocks
EXERCISE
THE HUMAN PROCESSOR
WRAP UP
For next time
• Read Chapter 2, Sections 2.6 – 2.8
• Learn about control, branch,
loops, etc.