carl hamcher

1. Instruction Execution: Straight-
line sequencing and branching

2. Instruction Execution and Straight-Line
Sequencing
R0,C
B,R0
A,R0
Movei + 8
Begin execution here Movei
ContentsAddress
C
B
A
the program
Data for
segment
program
3­instruction
Addi + 4
A program for C ← [Α] + [Β].
Assumptions:
- One memory operand
per instruction
- 32-bit word length
- Memory is byte
addressable
- Full memory address
can be directly specified
in a single-word instruction
Two-phase procedure
-Instruction fetch
-Instruction execute

3. Branching
NUMn
NUM2
NUM1
R0,SUM
NUMn,R0
NUM3,R0
NUM2,R0
NUM1,R0
A straight­line program for adding n numbers.
Add
Add
Move
SUM
i
Move
Add
i 4n+
i 4n 4­+
i 8+
i 4+
•
•
•
•
•
•
•
•
•

4. Branching
N,R1Move
NUMn
NUM2
NUM1
R0,SUM
R1
"Next" number to R0
Using a loop to add n numbers.
LOOP
Decrement
Move
LOOP
loop
Program
Determine address of
"Next" number and add
N
SUM
n
R0Clear
Branch>0
•
•
•
•
•
•
Branch target
Conditional branch

5. Condition Codes
• Condition code flags
• Condition code register / status register
• N (negative)
• Z (zero)
• V (overflow)
• C (carry)
• Different instructions affect different flags

6. Conditional Branch Instructions
• Example:
A: 1 1 1 1 0 0 0 0
B: 0 0 0 1 0 1 0 0
A: 1 1 1 1 0 0 0 0
+(−B): 1 1 1 0 1 1 0 0
1 1 0 1 1 1 0 0
C = 1
N = 1
V = 0
Z = 0

7. Status Bits
ALU
V Z N C
Zero Check
Cn
Cn-1
Fn-1
A B
F

8. Addressing Modes

9. Generating Memory Addresses
• How to specify the address of branch target?
• Can we give the memory operand address
directly in a single Add instruction in the loop?
• Use a register to hold the address of NUM1;
then increment by 4 on each pass through the
loop.

10. Addressing Modes
• Immediate
• Direct
• Indirect
• Register
• Register Indirect
• Displacement (Indexed)
• Implicit

11. Immediate Addressing
• Operand is part of instruction
• Operand = address field
• e.g. ADD 5
– Add 5 to contents of accumulator
– 5 is operand
• No memory reference to fetch data
• Fast
• Limited range

12. Immediate Addressing Diagram
OperandOpcode
Instruction

13. Direct Addressing
• Address field contains address of operand
• Effective address (EA) = address field (A)
• e.g. ADD A
– Add contents of cell A to accumulator
– Look in memory at address A for operand
• Single memory reference to access data
• No additional calculations to work out
effective address
• Limited address space

14. Direct Addressing Diagram
Address AOpcode
Instruction
Memory
Operand

15. Indirect Addressing (1)
• Memory cell pointed to by address field
contains the address of (pointer to) the
operand
• EA = (A)
– Look in A, find address (A) and look there for
operand
• e.g. ADD (A)
– Add contents of cell pointed to by contents of A to
accumulator

16. Indirect Addressing (2)
• Large address space
• 2n
where n = word length
• May be nested, multilevel, cascaded
– e.g. EA = (((A)))
• Draw the diagram yourself
• Multiple memory accesses to find operand
• Hence slower

17. Indirect Addressing Diagram
Address AOpcode
Instruction
Memory
Operand
Pointer to operand

18. Register Addressing (1)
• Operand is held in register named in address
filed
• EA = R
• Limited number of registers
• Very small address field needed
– Shorter instructions
– Faster instruction fetch

19. Register Addressing (2)
• No memory access
• Very fast execution
• Very limited address space
• Multiple registers helps performance
– Requires good assembly programming or compiler
writing
– N.B. C programming
• register int a;
• c.f. Direct addressing

20. Register Addressing Diagram
Register Address ROpcode
Instruction
Registers
Operand

21. Register Indirect Addressing
• C.f. indirect addressing
• EA = (R)
• Operand is in memory cell pointed to by
contents of register R
• Large address space (2n
)
• One fewer memory access than indirect
addressing

22. Register Indirect Addressing Diagram
Register Address ROpcode
Instruction
Memory
OperandPointer to Operand
Registers

23. Displacement Addressing
• EA = A + (R)
• Address field hold two values
– A = base value
– R = register that holds displacement
– or vice versa

24. Displacement Addressing Diagram
Register ROpcode
Instruction
Memory
OperandPointer to Operand
Registers
Address A
+

25. Relative Addressing
• A version of displacement addressing
• R = Program counter, PC
• EA = A + (PC)
• i.e. get operand from A cells from current
location pointed to by PC
• c.f locality of reference & cache usage

26. Base-Register Addressing
• A holds displacement
• R holds pointer to base address
• R may be explicit or implicit
• e.g. segment registers in 80x86

27. Indexed Addressing
• A = base
• R = displacement
• EA = A + (R)
• Good for accessing arrays
– EA = A + (R)
– R++

28. Combinations
• Postindex
• EA = (A) + (R)
• Preindex
• EA = (A+(R))
• (Draw the diagrams)

29. Implicit Addressing
• Operand is (implicitly) on top of stack
• e.g.
– ADD Pop top two items from stack
and add

30. Addressing Modes
• The different
ways in which
the location of
an operand is
specified in an
instruction are
referred to as
addressing
modes.
Name Assem bler syn tax Addressing function
Immediate #Value Operand = Value
Register Ri EA = Ri
Absolute(Direct) LOC EA = LOC
Indirect (Ri ) EA = [Ri ]
(LOC) EA = [LOC]
Index X(Ri) EA = [Ri ] + X
Basewith index (Ri ,Rj ) EA = [Ri ] + [Rj ]
Basewith index X(Ri,Rj ) EA = [Ri ] + [Rj ] + X
and offset
Relative X(PC) EA = [PC] + X
Autoincrement (Ri )+ EA = [Ri ] ;
Increment Ri
Autodecrement (Ri ) Decrement Ri ;
EA = [Ri]
−

31. Branching
N,R1Move
NUMn
NUM2
NUM1
R0,SUM
R1
"Next" number to R0
Using a loop to add n numbers.
LOOP
Decrement
Move
LOOP
loop
Program
Determine address of
"Next" number and add
N
SUM
n
R0Clear
Branch>0
•
•
•
•
•
•
Branch target
Conditional branch

32. Utility of using
Indirect
Addressing

33. Using Auto-increment Mode

34. Utility of Indexed Addressing
A list of students’ marks

35. Find sum of Test1, Test2 and Test 3
scores