Subroutines - Revision history

E5frog at 13:50, 12 April 2022

2022-04-12T13:50:39Z

E5frog: /* See Also */

2022-04-12T13:49:55Z

‎See Also

E5frog at 18:28, 15 March 2019

2019-03-15T18:28:00Z

E5frog at 18:29, 23 June 2018

2018-06-23T18:29:30Z

E5frog at 05:23, 22 January 2018

2018-01-22T05:23:16Z

E5frog at 05:20, 22 January 2018

2018-01-22T05:20:16Z

E5frog at 22:30, 16 November 2012

2012-11-16T22:30:50Z

E5frog: 1 revision

2012-11-16T21:23:46Z

1 revision

66.31.32.228 at 23:04, 13 October 2005

2005-10-13T23:04:32Z

New page

The F8 has no internal program counter stack, so you must be careful when calling subroutines. Using PI/POP only works for one level of subroutines, because the return address for the first PI opcode will be overwritten by subsequent PI opcodes. Here's a single-level example:

prog:
; ...do something...
pi sub
; ...do more...

sub:
; ...do something...
pop

To have 2 levels of subroutines, you can use the K register to save the first return address:

prog:
; ...do something...
pi sub1
; ...do more...

sub1:
lr k,p
; ...do something...
pi sub2
; ...do more...
pk

sub2:
; ...do something...
pop

That's as deep as the processor allows you to go without writing additional code to save return addresses. In the Channel F BIOS, there are routines which create a simulated [[stack]] for the K register. The routine at $0107 (known as PUSHK or CALL) can push K to the stack and the routine at $011E (known as POPK or RTRN) can pop K from the stack. For example:

prog:
; ...do something...
pi sub1
; ...do more...

sub1:
lr k,p
pi PUSHK
; ...do something...
pi sub2
; ...do more...
pi POPK
pk

sub2:
lr k,p
pi PUSHK
; ...do something...
pi sub3
; ...do more...
pi POPK
pk

By using PUSHK/POPK, you can have more than 2 levels of subroutine calls. However, a lot of overhead is added to the code by manipulating the stack. Whenever calling a subroutine one level deep, it's best to use the PI/POP combination; for two subroutines, it's best to use the second example above.

Also consider using macros- you have a lot more program space than the original Channel F programmers, so you might as well use it; the time you save can be considerable.

Blackbird is writing more efficient versions of PUSHK/POPK ([[Snippet:KStack]]). Another idea is to write a version that uses the Schach RAM at $2800 that MESS emulates. That would free up more scratchpad registers.

Here's a trick from the [http://members.cox.net/seanandalicia/F8GuideToProgramming.pdf Guide]: if a subroutine will be called frequently, it's quicker to load its address into the K register and call it using PK than to use PI multiple times.

=== See Also ===
* [http://members.cox.net/seanandalicia/F8GuideToProgramming.pdf F8 Guide to Programming]

@@ Line 172: / Line 172: @@
 Blackbird is writing more efficient versions of PUSHK/POPK ([[Snippet:KStack]]).  Another idea is to write a version that uses the Schach RAM at $2800 that MESS emulates.  That would free up more scratchpad registers and possibly also be quicker.
-Here's a trick from the [http://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf Guide]: if a subroutine will be called frequently, it's quicker to load its address into the K register and call it using PK than to use PI multiple times. You'll use 4.5 cycles instead of 6.5 cycles to do the same thing.
+Here's a trick from the [https://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf Guide]: if a subroutine will be called frequently, it's quicker to load its address into the K register and call it using PK than to use PI multiple times. You'll use 4.5 cycles instead of 6.5 cycles to do the same thing.
 It's also possible to change the Program Counter (PC0) with "lr P,Q" but there's no opcode for the other direction, address could be copied from A to Q in two steps or K to Q in four steps via Accumulator one byte at the time.

← Older revision		Revision as of 13:49, 12 April 2022
Line 178:		Line 178:

	=== See Also ===		=== See Also ===
−	* [~~http~~://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf F8 Guide to Programming]	+	* [https://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf F8 Guide to Programming]

@@ Line 65: / Line 65: @@
 By using PUSHK/POPK, you can have more than 2 levels of subroutine calls. However, a lot of overhead is added to the code by manipulating the stack. When inside a pushk/popk subroutine it's still possible to use plain pi/pop as it only affects PC0 and PC1. Whenever calling a subroutine one level deep, it's best to use the PI/POP combination; for two levels of subroutines, it's best to use the second example above. If using the K register in a subroutine only simple PI/POP is usable to get there, not to destroy contents of K.
+<pre>
 ;==================;
 ; Register K Stack ;
@@ Line 163: / Line 163: @@
 ;===================;
+</pre>

@@ Line 1: / Line 1: @@
-The F8 has no internal program counter stack, so you must be careful when calling subroutines.  Using PI/POP only works for one level of subroutines, because the return address for the first PI opcode will be overwritten by subsequent PI opcodes.  Here's a single-level example:
+The F8 has no internal stack for the program counter, so you must be careful when calling subroutines.  Using PI/POP only works for one level of subroutines, because the return address for the first PI opcode will be overwritten by subsequent PI opcodes.  Here's a single-level example:
     prog:
-        ; ...do something...
+        ; ...code
-        pi sub
+        pi sub                  ; Pushes address of next instruction to PC1
-        ; ...do more...
+                               ; address of sub is stored in PC0 (jump to subroutine)
     sub:
-        ; ...do something...
+        ; ... often used code
-        pop
+        pop                     ; Move return address from PC1 to PC0
 To have 2 levels of subroutines, you can use the K register to save the first return address:
@@ Line 14: / Line 17: @@
     prog:
         ; ...do something...
-        pi sub1
+        pi sub1                 ; Address of next instruction stored in PC1
         ; ...do more...
     sub1:
-        lr k,p
+        lr k,p                  ; Copy PC1 to K, original jump address to K
         ; ...do something...
-        pi sub2
+        pi sub2                 ; Pushes address of next instruction to PC1
         ; ...do more...
-        pk
+        pk                      ; Store address of next instruction in PC1
     sub2:
         ; ...do something...
-        pop
+        pop                     ; Move return address from PC1 to PC0
 That's as deep as the processor allows you to go without writing additional code to save return addresses.  In the Channel F BIOS, there are routines which create a simulated [[stack]] for the K register.  The routine at $0107 (known as PUSHK or CALL) can push K to the stack and the routine at $011E (known as POPK or RTRN) can pop K from the stack. For example:
@@ Line 58: / Line 64: @@
 By using PUSHK/POPK, you can have more than 2 levels of subroutine calls. However, a lot of overhead is added to the code by manipulating the stack. When inside a pushk/popk subroutine it's still possible to use plain pi/pop as it only affects PC0 and PC1. Whenever calling a subroutine one level deep, it's best to use the PI/POP combination; for two levels of subroutines, it's best to use the second example above. If using the K register in a subroutine only simple PI/POP is usable to get there, not to destroy contents of K.
 Also consider using macros- you have a lot more code space than the original Channel F programmers, so you might as well use it; the time you save can be considerable.
@@ Line 64: / Line 173: @@
 Here's a trick from the [http://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf Guide]: if a subroutine will be called frequently, it's quicker to load its address into the K register and call it using PK than to use PI multiple times. You'll use 4.5 cycles instead of 6.5 cycles to do the same thing.
 === See Also ===
 * [http://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf F8 Guide to Programming]

@@ Line 53: / Line 53: @@
         pk
-By using PUSHK/POPK, you can have more than 2 levels of subroutine calls. However, a lot of overhead is added to the code by manipulating the stack. When inside a pushk/popk subroutine it's still possible to use plain pi/pop inside it as it only affects PC0 and PC1. Whenever calling a subroutine one level deep, it's best to use the PI/POP combination; for two levels of subroutines, it's best to use the second example above. If using the K register in a subroutine only simple pi/pop is usable.
+   sub3:
 Also consider using macros- you have a lot more code space than the original Channel F programmers, so you might as well use it; the time you save can be considerable.

@@ Line 59: / Line 59: @@
 Blackbird is writing more efficient versions of PUSHK/POPK ([[Snippet:KStack]]).  Another idea is to write a version that uses the Schach RAM at $2800 that MESS emulates.  That would free up more scratchpad registers.
-Here's a trick from the [http://members.cox.net/seanandalicia/F8GuideToProgramming.pdf Guide]: if a subroutine will be called frequently, it's quicker to load its address into the K register and call it using PK than to use PI multiple times.
+Here's a trick from the [http://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf Guide]: if a subroutine will be called frequently, it's quicker to load its address into the K register and call it using PK than to use PI multiple times.
 === See Also ===
-* [http://members.cox.net/seanandalicia/F8GuideToProgramming.pdf F8 Guide to Programming]
+* [http://www.channelf.se/files/channelf/F8_Guide_to_Programming.pdf F8 Guide to Programming]

← Older revision	Revision as of 21:23, 16 November 2012
(No difference)