COSC 243. Assembly Language Techniques. Lecture 9. COSC 243 (Computer Architecture)

Transcription

1 COSC 243 Assembly Language Techniques 1

2 Overview This Lecture Source Handouts Next Lectures Memory and Storage Systems 2

3 Parameter Passing In a high level language we don t worry about the number of parameters passed to a routine: add4(a, b, c, d); But in assembly how do we pass more parameters than there are registers? On the 6502 there are 3 registers we might use: A, X, Y How do we pass 4 parameters? 3

4 Parameter Passing This can be solved no-matter how many parameters The solution is called the calling-convention. It differs from high-level language to language. In C: 1. Push the parameters onto the stack (typically in reverse order) 2. Call the subroutine 3. The subroutine does the processing and returns 4. The stack is returned to its previous state To do this we need indexed addressing 4

5 Revision: Indexed Addressing The value to use is stored at the memory location that is the sum of the operands Useful for accessing stack-based parameters to a routine Examples include: LDY $311E,X ; Use memory location ($311E+X) X $10 LDY $311E,X Value Indexed F 312E 312D 312C 5

6 Example: Double a number In C: unsigned char double(unsigned char value); int main(void) { return double (0x10); } unsigned char double(unsigned char value) { return value + value; } 6

7 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 END: 0017 JMP END 001A DOUBLE: 001A TSX A 00 X 00 Y 00 S PC D 6F F3 BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 7

8 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 10 X 00 Y 00 S PC D 6F F3 BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 8

9 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 10 X 00 Y 00 S FC PC F F3 BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 9

10 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 10 X 00 Y 00 S PC FA 001A BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 10

11 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 10 X FA Y 00 S PC FA 001B BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 11

12 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX 001B LDA $0103,X 001E ADC $0103,X X FA A 10 X FA Y 00 S FA PC 001E $ X BC CD B5 01FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 01F6 01F STA $0103,X 89 01F RTS 23 01F F2 12

13 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX 001B LDA $0103,X 001E ADC $0103,X X FA A 20 X FA Y 00 S FA PC 0021 $ X BC CD B5 01FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 01F6 01F STA $0103,X 89 01F RTS 23 01F F2 13

14 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX 001B LDA $0103,X 001E ADC $0103,X X FA A 20 X FA Y 00 S FA PC 0024 $ X BC CD B5 01FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 01F6 01F STA $0103,X 89 01F RTS 23 01F F2 14

15 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 20 X FA Y 00 S FC PC BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 15

16 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 20 X FA Y 00 S PC BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 16

17 Example Registers Memory * = $ START: 0010 LDA #$ PHA 0013 JSR DOUBLE 0016 PLA 0017 OVER: 0017 JMP OVER 001A DOUBLE: 001A TSX A 20 X FA Y 00 S PC BC FF 01FE 01 01FC 01FB 01FA 01F9 01F8 01F7 001B LDA $0103,X CD 01F6 001E ADC $0103,X B5 01F STA $0103,X 89 01F RTS 23 01F F2 17

18 Return Values In high level languages functions also return values Options: Store in a global variable Store on the stack Store in a register In C: 5. Return value in accumulator A Piecing it all together A subroutine that returns the sum of 4 unsigned chars 18

19 Example (Add 4 Numbers) START: END: LDA #$40 PHA LDA #$30 PHA LDA #$20 PHA LDA #$10 PHA JSR ADD4 TAX PLA PLA PLA PLA TXA JMP END ADD4: TSX LDA #$00 CLC ADC $103,X ADC $104,X ADC $105,X ADC $106,X RTS 19

20 Recursion (Fibonacci) #include <stdio.h> int main(void) { unsigned char result; result = fibonacci(7); printf("%d\n", result); return 0; } unsigned char fibonacci(unsigned char iteration) { unsigned left, right; if (iteration < 2) return 1; else { left = fibonacci(iteration - 1); right = fibonacci(iteration - 2); return left + right; } } COSC

21 Recursion (Fibonacci) START: LDA #$07 PHA JSR FIBONACCI PLA END: JMP END TMP: DCB $00 FIBONACCI: TXA ; save X PHA TYA ; save Y PHA TSX ; get stack LARGE: DEC $105,X LDA $105,X PHA JSR FIBONACCI TAY PLA DEC $105,X SMALL: LDA #$01 DONE: STA TMP PLA TAY ; restore Y PLA TAX ; restore X LDA TMP RTS LDA $105,X CMP #$02 BMI SMALL LDA $105,X PHA JSR FIBONACCI STA TMP PLA TYA CLC ADC TMP JMP DONE 21

22 Preamble and Postamble In the example, on entry to the routine we see the preamble: TXA ; save X PHA TYA ; save Y PHA TSX ; get stack This saves the registers we are going to use and loads the top of stack into X for indirect addressing At the end of routine postamble the registers are restored: PLA TAY PLA TAX ; restore Y ; restore X 22

23 Local Variables For recursion with local variables, the parameters and the local variables must both be stored on the stack This is one of the tasks of the compiler Exercise (in your own time) Rewrite the assembly in the recursion example to put TMP on the stack This gives us the traditional high level language procedural programming paradigm 23

24 Self-Modifying Code Recall Von Neumann Code and data are the same thing This can be exploited in assembly If we have 2 (or more) routines that do nearly the same thing then we can code it once and then write a program that changes the program. We call this selfmodifying code Example, a program that either ADDs or SUBTRACTs the members of an array 24

25 Self-Modifying Code START: LDX #ARRAY JSR MINUS END: ARRAY: JMP END DCB 1,2,3,4,5,6,7,8,9,0 PLUS: LDA #$7D ; ADC CLC JMP OPERATE MINUS: LDA #$ ; SBC SEC JMP OPERATE ; clear carry ; clear borrow OPERATE: LOOP: STA PL_MI LDA #$00 LDY $00,X CPY #$00 BEQ DONE PL_MI: ADC $00,X INX JMP LOOP DONE: RTS 25

26 Manipulate PC at Runtime The value of PC can be manipulated at run time. Recall that on a RTS PC is loaded with the value at the top of the stack (then 1 is added), so these are equivalent: *=$0010 START: LDA #$00 PHA *=$0010 START: JMP START LDA #$0F PHA RTS 26

27 Manipulate PC at Runtime This technique can also be used to change the return address inside subroutine call. This is useful if you want to return to a different address to the call address. This technique can be used to pass parameters inline 27

28 *=$0000 JMP START LO HI START END Manipulate PC at Runtime.BYTE $00.BYTE 00 JSR PLUS.BYTE $03.BYTE $06 JMP END PLUS TSX LDA $101,X STA LO LDA $102,X STA HI INC $101,X INC $101,X LDY #$01 LDA (LO),Y LDY #$02 CLC ADC (LO),Y RTS ; get return adress Lo ; save it ; get return addres Hi ; save it ; add 2 to return address ; so that RTS will skip data ; load first parameter ; recall, off buy 1 on RTSs ; store in A ; load seccond parameter ; clear the carry ; add to A NOTE: This program does not work with the assembler used in Lab 3. Remove the comments then try it here: 28

29 What Else? JMP START On an 8-bit 16-bit arithmetic? 32-bit arithmetic? 64-bit arithmetic? In this example we store the integers low-byte first then high byte. FIRST: DCB $CD DCB $F2 SECOND: DCB $10 DCB $20 RESULT: DCB $00, $00 START: LDX #$00 ; byte 0 CLC ; clear carry LDA FIRST,X ; $CD ADC SECOND,X ; $10 STA RESULT,X ; save ; don t clear carry INX ; byte 1 LDA FIRST,X ; $F2 ADC SECOND,X ; $20 STA RESULT,X ; save END: JMP END 29