Stacks and Subroutines May 23. Stacks and subroutine usage The stack is a special area of the random access memory in the overall memory system The stack.

Slides:



Advertisements
Similar presentations
Ch. 7 Local Variables and Parameter Passing From the text by Valvano: Introduction to Embedded Systems: Interfacing to the Freescale 9S12.
Advertisements

Week 8 Stack and Subroutines. Stack  The stack is a section of data memory (or RAM) that is reserved for storage of temporary data  The data may represent.
CPU Review and Programming Models CT101 – Computing Systems.
1/1/ / faculty of Electrical Engineering eindhoven university of technology Introduction Part 2: Data types and addressing modes dr.ir. A.C. Verschueren.
INSTRUCTION SET ARCHITECTURES
1 Lecture 4: Procedure Calls Today’s topics:  Procedure calls  Large constants  The compilation process Reminder: Assignment 1 is due on Thursday.
Procedure Calls Prof. Sirer CS 316 Cornell University.
EECC250 - Shaaban #1 Lec # 6 Winter Stack-Related Instructions PEA Push Effective Address Calculates an effective address and pushes it.
ECE 353 Introduction to Microprocessor Systems Michael G. Morrow, P.E. Week 6.
Software engineering, program management. The problem  Software is expensive to design! – Industry estimates put software development labor costs at.
S. Barua – CPSC 240 CHAPTER 10 THE STACK Stack - A LIFO (last-in first-out) storage structure. The.
EECC250 - Shaaban #1 Lec # 5 Winter Stacks A stack is a First In Last Out (FILO) buffer containing a number of data items usually implemented.
Stacks and Subroutines ELEC 330 Digital Systems Engineering Dr. Ron Hayne Images Courtesy of Ramesh Gaonkar and Delmar Learning.
© 2010 Kettering University, All rights reserved..
Chapter 10 And, Finally... The Stack. Copyright © The McGraw-Hill Companies, Inc. Permission required for reproduction or display Stacks A LIFO.
Chapter 10 The Stack Stack: An Abstract Data Type An important abstraction that you will encounter in many applications. We will describe two uses:
CS-2710 Dr. Mark L. Hornick 1 Defining and calling procedures (subroutines) in assembly And using the Stack.
Machine Instruction Characteristics
Stacks and Subroutines. Some example stacks Stacks and subroutine usage The stack is a special area of the random access memory in the overall memory.
ECE 265 – LECTURE 8 The M68HC11 Basic Instruction Set The remaining instructions 10/20/ ECE265.
Interrupts and reset operations. Overview  Introduction to interrupts – What are they – How are they used  68HC11 interrupt mechanisms – Types of interrupts.
Objective At the conclusion of this chapter you will be able to:
Passing Parameters using Stack Calling program pushes parameters on the stack one element at a time before calling subroutine. Subroutine Call (jsr, bsr)
ELE22MIC Lecture 8 ASll Examples –16 Bit Counters –Buffalo Jump Table Interrupt processing (IRQ/RTI) Stack Frame & Base Pointer Wired OR.
ITCS 3181 Logic and Computer Systems 2015 B. Wilkinson Slides4-2.ppt Modification date: March 23, Procedures Essential ingredient of high level.
ECE 265 – LECTURE 5 The M68HC11 Basic Instruction Set 12/8/ ECE265.
1 Stacks, Subroutines, I/O Routines Today: First Hour: Stacks, Subroutines –Section 3.9,3.10 of Huang’s Textbook –In-class Activity #1 Second Hour: I/O.
1 ECE 372 – Microcontroller Design Assembly Programming HCS12 Assembly Programming Addressing Modes Stack Operations Subroutines.
Advanced Assembly Language Programming
Subroutines and Stacks. Stack The stack is a special area in memory used by the CPU to store register information or general data information during program.
1 Subroutines Advanced Programming. 2 Top-Down approach to problem solving Algorithm step by step description of how to solve a problem Divide and Conquer.
1 Stack Advanced Programming. 2 The Stack It is a special area of memory used as temporary storage A stack is a LIFO data structure Putting data into.
Revised: Aug 1, EE4390 Microprocessors Lessons 11, 12 Advanced Assembly Programming.
5-1 EE 319K Introduction to Microcontrollers Lecture 5: Conditionals, Loops, Modular Programming, Sub- routines, Parameter passing.
CPEN 231: Microcomputer Architecture and Assembly Programming Lecture 10: Stack and Subroutines John Tadrous, Ph.D. ECE Rice University
Computer Science 210 Computer Organization
EET 2261 Unit 6 The Stack; Subroutines
Computer structure: Procedure Calls
ECE 3430 – Intro to Microcomputer Systems
Figure 8.1 of course package
ECE 3430 – Intro to Microcomputer Systems
Control Structure Applications
The Stack.
ECE 3430 – Intro to Microcomputer Systems
ECE 3430 – Intro to Microcomputer Systems
Introduction of microprocessor
Chapter 10 And, Finally... The Stack
Chapter 10 The Stack.
Arithmetic using a stack
Branching and Looping Lecture L3.2.
Control Structure Applications
MIPS Instructions.
Chapter 8 Central Processing Unit
The University of Adelaide, School of Computer Science
Computer Science 210 Computer Organization
Chapter 10 And, Finally... The Stack
EE6502/MPMC/UNIT II/STACK AND SUBROUTINE/T.THARANKUMAR
Lecture 6: Assembly Programs
Procedures and Calling Conventions
ME 4447/6405 Microprocessor Control of Manufacturing Systems and
8051 ASSEMBLY LANGUAGE PROGRAMMING
ECE 447: Lecture 15 Stack Operations.
EET 2261 Unit 6 The Stack; Subroutines
Computer Architecture
Where is all the knowledge we lost with information? T. S. Eliot
Computer Organization and Assembly Language
ME 4447/6405 Microprocessor Control of Manufacturing Systems and
ME 4447/6405 Microprocessor Control of Manufacturing Systems and
ECE511: Digital System & Microprocessor
Lecture 3 - Instruction Set - Al
Presentation transcript:

Stacks and Subroutines May 23

Stacks and subroutine usage The stack is a special area of the random access memory in the overall memory system The stack is used for – General data storage (limited) – Temporary data storage (true) – Parameter and control information storage for subroutines (yes!)

Stacks Last-in, first-out (LIFO) structure All access is at the top of the stack Operations – Push » Places an item onto the stack – Pull » Removes an item from the stack » Some (most!) people use the term “pop” Bottom of the stack is at highest memory address, and top of the stack is at the lowest address – Stack grows from high to low address – For EVBU, stack is usually placed at $01FF Stack Pointer (SP) – Register that points to the memory location immediately preceding the top of the stack – In other words, the SP normally contains the address for a new data item to be pushed

Low Address High Address Bottom SP

Push instructions – PSHA, PSHB, PSHX, PSHY » Stores data in memory at address pointed to by SP » Decrements SP » For 16-bit values, low- order byte is pushed first, followed by high-order byte data1 data2 data3 dataA dataXL dataXH SP SP-1 SP-2 SP-3 (New top of stack) RAM dataXHdataXL IX ACCA dataXH LDAA #dataA PSHA LDX #dataX PSHX (a) Push data onto stack to store it

Pull instructions – PULA, PULB, PULX, PULY » Increments SP» Decrements SP » Loads data from memory address pointed to by SP data1 data2 data3 dataA dataXL dataXH SP+3 SP+2 SP+1 SP (New top of stack) RAM dataXHdataXL IX ACCA dataA PULX PULA (a) Pull data from stack to receive it Stack Pointer

Other stack operations – Can modify or read the SP LDSLoad the SP STSStore the SP INSIncrement SP DESDecrement SP TSXTransfer SP+1 to IX TSYTransfer SP+1 to IY TXSTransfer IX-1 to SP TYSTransfer IY-1 to SP

Stacks – Remember to initialize SP at beginning of program – Important to pull data in reverse order that you pushed it – Note that SP points to empty memory location (= location where next value will be stored)

Using the stack – Passing parameters to subroutines (more on this later) – Temporary storage » 68HC11 has limited number of registers » Use stack to preserve register values Example: Multiply ACCA and ACCB, round to 8 bits PSHB; save value in ACCB MUL; ACCD = ACCA*ACCB ADCA #$00; round to 8 bits PULB; restore ACCB

Using the stack – You can also use the stack to save intermediate values – Example: This calculates x squared plus y squared. x and y are 8-bit numbers stored in addresses $1031 and $1032. The 8-bit result is put in ACCA. ORG$E000 BEGIN:LDS#$FF ; initialize SP LDAA$1031; get x value TAB; square it MUL ADCA#$00; round to 8 bits PSHA; save it LDAA$1032; get y value TAB; square it MUL ADCA#$00; round to 8 bits PULB; retrieve first result ABA; add them

Dangers in using the stack – Overflow » Too many pushes » Stack grows so large that it overwrites portions of memory that are being used for other purposes » Example: ORG$E0 FOORMB2 ORG$E000 LDS#$FF; initialize SP LDAB#$FF; initialize loop count LOOP:PSHA; push value on stack DECB; decrement count BNELOOP; and repeat

Dangers in using the stack (continued) – Underflow » Too many pulls » SP points to address higher than the intended bottom of the stack – The HC11 does not protect you from overflow or underflow! » Only way to recover is to reset the system » Be aware of the stack size that your program needs. – Typical memory layout for EVBU: » 512 bytes of RAM ($00-$1FF) » $00 - $FF used by Buffalo monitor Don’t use these locations in your programs » User variables should start at $100 ($100-?) » Stack starts at $1FF (? - $1FF) » More variables = less stack space

Why use them? – Provides modularity to reduce program complexity – Creates many smaller, but more easily developed and tested program units – May save on memory space (to store program) – Can be reused in different parts of a program – Can be placed in a library for use by many programs and applications

Subroutines should... – Be small, to ease writing, testing, and modifying – Have a well defined purpose – Have a well defined interface – Be well documented (like the rest of the program!) » Describe input parameters Registers, memory locations, values on the stack, etc. » Describe output parameters Registers, memory locations, stack, condition codes » Describe any side effects Registers that are changed, condition codes, etc.

Example of proper documentation format: ;****************************** ; Function: ToUpper ; This function replaces all lower-case ; characters in a string with upper-case. ; The end of the string is marked with ; $00. ; Input: IX = starting address of string ; Output: none ; Registers affected: ACCA, CCR ;*******************************

Calling a subroutine JSRsbr BSRsbr – Address of next instruction (return address) is pushed onto the stack » This is the current value of PC – PC is loaded with the starting address of the subroutine » Next instruction fetched will be from the subroutine

Returning from a subroutine – RTS instruction – Must be the last instruction in subroutine – Pops return address off the stack, loads it into PC » Next instruction fetch will be the instruction following the JSR/BSR – If your subroutine manipulates the stack, be aware of where the return address is stored. » It must be at the top of the stack when you execute the RTS

Subroutine parameter passing -- how are the parameters / arguments for the subroutine passed to it? – Registers » Parameters are placed in predetermined register locations » Simple and fast » Number of parameters is limited by the number of "free" registers » Code is not reentrant – Dedicated memory » A series of (predetermined) memory locations are used to hold the parameters » Simple, but added overhead due to memory operations » Possible to pass many parameters » Code is not reentrant

Pointer to memory  Pass the subroutine a register value containing the address of the parameters in memory  More complex, extra overhead for use of the pointer  Code is reentrant Use the stack  Parameters, in addition to the return address, are pushed onto the stack -- the combination is called the stack frame You must push the parameters before the JSR/BSR  Requires care in manipulating the parameters Don’t forget about the return address!  Many parameters can be passed  Separate parameter stack can be created and used in addition to the system stack  Code is reentrant

Example Example: Timing delay  Write a subroutine that will delay for a specified number of milliseconds. The delay time is passed as a parameter in ACCB. The subroutine should also preserve the contents of all registers as well as the condition codes Main program: LDAB #$0A ; delay for 10 ms JSR DELAY

Example Example: Write a subroutine to find the maximum of two signed 8-bit numbers. The two numbers are passed to the subroutine on the stack, and the maximum is returned to the calling routine on the stack. Main program: LDAA #$73 ; load the 2 values LDAB #$A8 PSHA ; push them on the stack PSHB JSR MAX ; find the max PULA ; pull max off stack

Example Example: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subroutine - MAX ; This subroutine returns the maximum of 2 ; signed 8-bit numbers. ; Input - The 2 numbers are passed on the stack ; Output - The maximum is returned on the stack ; Registers used - ACCA, ACCB, IY, CCR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; MAX: PULY ; save return address PULB ; get the 2 numbers PULA CBA ; compare them BGT A_IS_MAX ; branch if ACCA > ACCB B_IS_MAX: PSHB ; return the value in ACCB BRA MAX_EXIT A_IS_MAX: PSHA ; return the value in ACCA MAX_EXIT: PSHY ; put return address back on stack RTS ; and return Cont..

Example Example: Convert an 8-bit hex number into 2 ASCII characters  For example, convert $3F into ‘3’ and ‘F’ The hex number is passed to the subroutine on the stack, and the 2 ASCII characters are returned on the stack, with the high-order character on top. Main program: LDAA #$3F ; get hex number PSHA JSR HEX_TO_ASCII ; convert it PULB ; ACCB = ‘3’ = $33 PULA ; ACCA = ‘F’ = $46

Example Converting hex digit to 2 ASCII characters  Pseudo code: Get hex digit from stack Convert lower nibble to ASCII Push char on stack Convert upper nibble to ASCII Push char on stack Return We’ll use a second subroutine to convert a nibble to ASCII  Note that the ASCII codes for 0-9 are $30-$39, and the codes for A-F are $41-$46  Pseudo code: Add #$30 to nibble If (result > $39) Add #$07 Return Cont..

Example Example: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subroutine - CONVERT_NIBBLE ; This subroutine converts a nibble (4-bit value) ; to ASCII. ; Input: ACCB contains the nibble ; Output: ACCB contains the ASCII code ; Registers affected: None ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; CONVERT_NIBBLE: PSHA ; save ACCA TPA ; save CCR PSHA ADDB #$30 ; convert to ASCII CMPB #$39 ; is nibble > 9? BLS CN_EXIT ; branch if not ADDB #$07 ; for A-F CN_EXIT: PULA ; restore CCR TAP PULA ; restore ACCA RTS ; return Cont..

Example Example: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subroutine - HEX_TO_ASCII ; This subroutine converts an 8-bit hex number ; to two ASCII digits. ; Input: Hex number is passed on the stack ; Output: ASCII characters are returned on the ; stack, with the high-order nibble on top. ; Registers affected: ACCA, ACCB, IY, CCR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; HEX_TO_ASCII: PULY ; save return address PULA ; get hex number TAB ; copy it to ACCB ANDB #$0F ; get lower nibble JSR CONVERT_NIBBLE PSHB ; save ASCII on stack TAB ; get hex number again LSRB ; get upper nibble LSRB JSR CONVERT_NIBBLE PSHB ; save ASCII on stack PSHY ; push return address RTS ; and return Cont..

Summary Stack  Be sure to initialize the stack pointer at the beginning of your program LDS #$1FF Don’t do this if you’re calling your program from Buffalo Buffalo initializes SP for you  Push and Pull operations  Remember SP points to next empty location

Summary Subroutines  Break your program into subroutines Don’t do this if you’re calling your program from Buffalo Well-defined (and documented!) function Well-defined (and documented!) interface  Passing parameters Use registers if possible Else, use stack if needed – Don’t forget about the return address