mirror of
https://gitlab.com/camelot/kickc.git
synced 2024-06-03 07:29:37 +00:00
- Added javadoc documentation in Bank.java.
- Added reworked procedure-callingconvention-phi-bank-5.c to reflect a good banking example for the documentation. - Update ref for test cases.
This commit is contained in:
Flight_Control
parent
bdc4e28d0a
commit
1499f8cecc
|
|
@ -1,10 +1,226 @@
|
|||
package dk.camelot64.kickc.model;
|
||||
|
||||
/** A Bank segment. */
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* <p>
|
||||
* Specific target computer platforms implement a memory layout that can be banked either in ram or rom.
|
||||
* This class models the capability to calculate which function call implementations are banked and which not.
|
||||
* <br>Since banking implementations are specific to the target computer platform,
|
||||
* specific assembler fragments are available in the compiler,
|
||||
* that model the implementation of the banking, depending on:
|
||||
*
|
||||
* <ul>
|
||||
* <li>the computer target computer <b><i>platform</i></b>.</li>
|
||||
* <li>the bank <b><i>method</i></b> of function call implementation at the call location.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The <b></b><i>method</i></b> can implement different banking implementations,
|
||||
* depending on the required function call speed,
|
||||
* the banking routine availability in the kernal (rom) of the target computer <b><i>platform</i></b>
|
||||
* or even using specific designed banking routines by kickc to provide alternatives for banking methods.
|
||||
* The <b><i>method</i></b> and the <b><i>platform</i></b> are the key combinations that select the fragments
|
||||
* in kickc to generate the banked function call implementations used by the compiler.
|
||||
*
|
||||
* <p>Your C-code can be augmented with 3 new directives, that define which function(s) will be declared as banked:
|
||||
*
|
||||
* <br><ul>
|
||||
* <li><b>#pragma bank( <i>method</i>, <i>number</i> )</b> directive, defines for sequent functions
|
||||
* the target bank <b><i>number</i></b> and the <b><i>method</i></b> for the banked function call implementations.</li>
|
||||
* <li>A new <b>#pragma nobank( dummy )</b> directive, resets the calculation of banking for sequent functions
|
||||
* not to calculate any banking for these functions.</li>
|
||||
* <li>A new <b>__bank( <i>method</i>, <i>number</i> )</b> directive, defines for one function a
|
||||
* target bank <b><i>number</i></b> and the <b><i>method</i></b> for the banked function call implementation.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The compiler decides automatically the function call implementation, which can be either banked or not.
|
||||
* And if the function call implementation is banked, it should use the specified bank number to implement
|
||||
* the banked function call.
|
||||
* The rules can be summarized as follows:
|
||||
*
|
||||
* <ul>
|
||||
* <li>If a function is declared <b>not banked</b>, and the function call location is <b>not banked</b>,
|
||||
* the function call implementation will be <b>not banked</b>.</li>
|
||||
* <li>If a function is declared <b>banked</b>, and the function call location is not <b>banked</b>,
|
||||
* the function call implementation will be <b>banked</b>.</li>
|
||||
* <li>If a function is declared <b>not banked</b>, and the function call location is <b>banked</b>,
|
||||
* the function call implementation will be <b>not banked</b>.</li>
|
||||
* <li>If a function is declared <b>banked</b>, and the function call location is <b>banked</b>,
|
||||
* but the function call location is within the same bank,
|
||||
* the function call implementation will be <b>not banked</b>.</li>
|
||||
* <li>If a function is declared <b>banked</b>, and the function call location is <b>banked</b>,
|
||||
* but the function call location is <b>not within the same bank</b>,
|
||||
* the function call implementation will be <b>banked</b>.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The usage of <b>#pragma code_seg( <i>segment</i> )</b> directive
|
||||
* is very important! The <b>#pragma code_seg( <i>segment</i> )</b> directive utilization
|
||||
* in harmony with the <b>#pragma bank( <i>method</i>, <i>number</i> )</b> directive
|
||||
* makes the overall banking implementation work for your program.
|
||||
*
|
||||
* <p>
|
||||
* <ul>
|
||||
* <li>KickC uses the <b>#pragma code_seg( <i>segment</i> )</b> directive to calculate the
|
||||
* <b>addressing</b> of the allocation of the function code within main or banked memory.</li>
|
||||
* <li>KickC uses the <b>#pragma bank( <i>method</i>, <i>number</i> )</b> directive or
|
||||
* <b>__bank( <i>method</i>, <i>number</i> )</b> directive to calculate the function call implementation
|
||||
* at the function calling locations!</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>
|
||||
* The best way to describe the usage with a comprehensive example, documenting the different use cases
|
||||
* how the compiler decides which functions are banked or not,
|
||||
* and how the resulting banked function call code will be generated.
|
||||
* <p>
|
||||
* The example implements several functions in various forms to allocate the code in main memory
|
||||
* using segment <b>Code</b> and within 3 banked memory locations, using segments <b>Bank1</b>, <b>Bank2</b>, <b>Bank3</b>.
|
||||
* In order to ensure a good understanding of the example, the usage of these code segments in harmony with the
|
||||
* banking directives must be described, which is absolutely necessary to master,
|
||||
* in order to make banked function calls work.
|
||||
*
|
||||
* <p>
|
||||
* <ul>
|
||||
* <li>The #pragma directive <b>code_seg( Code )</b> defines the sequent function code to be allocated
|
||||
* within main (not banked) memory, defined within segment <b>Code<><b/> by the linker.</li>
|
||||
* <li>The #pragma directive <b>code_seg( Bank1 )</b> defines the sequent function code to be allocated
|
||||
* within banked memory, defined within segment <b>Bank1</b> by the linker.</li>
|
||||
* <li>The #pragma directive <b>code_seg( Bank2 )</b> defines the sequent function code to be allocated
|
||||
* within banked memory, defined within segment <b>Bank2</b> by the linker.</li>
|
||||
* <li>The #pragma directive <b>code_seg( Bank3 )</b> defines the sequent function code to be allocated
|
||||
* within banked memory, defined within segment <b>Bank3</b> by the linker.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Note that the <b>Code</b> segment is the default location in KickC where the code is placed by the linker.
|
||||
*
|
||||
* Find below the code example, which is also the program procedure-callingconvention-phi-bank-5.c
|
||||
*
|
||||
* <pre>
|
||||
*
|
||||
* // The linker specification of the different segments.
|
||||
* #pragma link("procedure-callingconvention-phi-bank-5.ld")
|
||||
*
|
||||
* // The target computer platform is the Commander X16,
|
||||
* // which implements banking in ram between 0xA0000 and 0xBFFF,
|
||||
* // and in rom between 0xC000 and 0xFFFF.
|
||||
* #pragma target(cx16)
|
||||
*
|
||||
* char *const SCREEN = (char *)0x0400; // Just for test purposes.
|
||||
*
|
||||
* #pragma code_seg(Bank1) // The sequent functions will be addressed specified by segment bank1 in the linker.
|
||||
* #pragma bank(ram, 1) // The sequent functions will be banked using call method ram in bank number 1.
|
||||
*
|
||||
* // Function declarations
|
||||
* char func_ram_bank1_a(char a, char b);
|
||||
* char __bank(ram, 1) func_ram_bank1_b(char a, char b);
|
||||
* char func_ram_bank1_c(char a, char b);
|
||||
* char func_ram_bank1_d(char a, char b);
|
||||
* char func_ram_bank1_e(char a, char b);
|
||||
* char func_ram_bank1_f(char a, char b);
|
||||
* char func_rom_bank2_a(char a, char b);
|
||||
* char __bank(rom, 2) func_rom_bank2_b(char a, char b);
|
||||
* char func_rom_bank2_c(char a, char b);
|
||||
* char func_rom_bank2_d(char a, char b);
|
||||
* char func_rom_bank2_e(char a, char b);
|
||||
* char func_rom_bank2_f(char a, char b);
|
||||
* char func_main_a(char a, char b);
|
||||
* char func_main_b(char a, char b);
|
||||
*
|
||||
* // Functional code
|
||||
*
|
||||
* char func_ram_bank1_a(char a, char b) {
|
||||
* return a + b;
|
||||
* }
|
||||
*
|
||||
* char func_ram_bank1_c(char a, char b) {
|
||||
* return func_ram_bank1_a(a, b); // Non banked call in ram bank 1.
|
||||
* }
|
||||
*
|
||||
* char func_ram_bank1_d(char a, char b) {
|
||||
* return func_rom_bank2_a(a, b); // Banked call from ram bank 1 to rom bank 2.
|
||||
* }
|
||||
*
|
||||
* char func_ram_bank1_e(char a, char b) {
|
||||
* return func_rom_bank2_b(a, b); // Banked call from ram bank 1 to rom bank 2.
|
||||
* }
|
||||
*
|
||||
* char func_ram_bank1_f(char a, char b) {
|
||||
* return func_main_a(a, b); // Non banked call from ram bank 1 to main memory.
|
||||
* }
|
||||
*
|
||||
*
|
||||
* #pragma code_seg(Bank2) // The sequent functions will be addressed specified by segment bank2 in the linker.
|
||||
* #pragma bank(rom, 2) // The sequent functions will be banked using call method rom in bank number 2.
|
||||
*
|
||||
* char func_rom_bank2_a(char a, char b) {
|
||||
* return a + b;
|
||||
* }
|
||||
*
|
||||
* char func_rom_bank2_c(char a, char b) {
|
||||
* return func_ram_bank1_a(a, b); // Banked call from rom bank 2 to ram bank 1.
|
||||
* }
|
||||
*
|
||||
* char func_rom_bank2_d(char a, char b) {
|
||||
* return func_rom_bank2_a(a, b); // Non banked call in rom bank 2.
|
||||
* }
|
||||
*
|
||||
* char func_rom_bank2_e(char a, char b) {
|
||||
* return func_rom_bank2_b(a, b); // Non Banked call in rom bank 2.
|
||||
* }
|
||||
*
|
||||
* char func_rom_bank2_f(char a, char b) {
|
||||
* return func_main_a(a, b); // Non banked call from rom bank 2 to main memory.
|
||||
* }
|
||||
*
|
||||
*
|
||||
* #pragma nobank(dummy) // The sequent functions will consider no banking calculations anymore.
|
||||
*
|
||||
* // The __bank directive declares this function to be banked using call method ram in bank number 1 of banked ram.
|
||||
* char __bank(ram, 1) func_ram_bank1_b(char a, char b) {
|
||||
* return a + b;
|
||||
* }
|
||||
*
|
||||
* // The __bank directive declares this function to be banked using call method rom in bank number 2 of banked rom.
|
||||
* char __bank(rom, 2) func_rom_bank2_b(char a, char b) {
|
||||
* return a + b;
|
||||
* }
|
||||
*
|
||||
* #pragma code_seg(Code) // The sequent functions will be addressed in the default main memory location (segment Code).
|
||||
*
|
||||
* // Allocated in main memory.
|
||||
* char func_main_a(char a, char b) {
|
||||
* return func_ram_bank1_e(a, b); // Banked call to ram in bank 1 from main memory.
|
||||
* }
|
||||
*
|
||||
* // Allocated in main memory.
|
||||
* char func_main_b(char a, char b) {
|
||||
* return func_rom_bank2_e(a, b); // Banked call to rom in bank 2 from main memory.
|
||||
* }
|
||||
*
|
||||
* // Practically this means that the main() function is placed in main memory ...
|
||||
*
|
||||
* void main(void) {
|
||||
* SCREEN[0] = func_ram_bank1_a('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
* SCREEN[0] = func_ram_bank1_b('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
* SCREEN[0] = func_ram_bank1_c('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
* SCREEN[0] = func_ram_bank1_d('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
* SCREEN[0] = func_ram_bank1_e('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
* SCREEN[0] = func_ram_bank1_f('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
* SCREEN[0] = func_rom_bank2_a('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
* SCREEN[0] = func_rom_bank2_b('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
* SCREEN[0] = func_rom_bank2_c('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
* SCREEN[0] = func_rom_bank2_d('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
* SCREEN[0] = func_rom_bank2_e('0', 7); // banked call to rom in bank 2 from main memory.
|
||||
* SCREEN[0] = func_rom_bank2_f('0', 7); // banked call to rom in bank 2 from main memory.
|
||||
* SCREEN[0] = func_main_a('0', 7); // Near call in main memory from main memory.
|
||||
* SCREEN[0] = func_main_b('0', 7); // Near call in main memory from main memory.
|
||||
* }
|
||||
* </pre>
|
||||
*/
|
||||
public class Bank {
|
||||
|
||||
private final String bankArea;
|
||||
private Long bank;
|
||||
private final String bankArea; // The bank method to apply.
|
||||
private Long bank; // The bank number.
|
||||
|
||||
public Bank(String bankArea, Long bank) {
|
||||
this.bankArea = bankArea;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
// Test a far call procedure with a calling convention phi
|
||||
|
||||
#pragma code_seg(stage)
|
||||
#pragma link("procedure-callingconvention-phi-bank.ld")
|
||||
#pragma target(cx16)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,104 +1,119 @@
|
|||
// Test a far call procedure with a calling convention phi
|
||||
|
||||
#pragma code_seg(stage)
|
||||
#pragma link("procedure-callingconvention-phi-bank.ld")
|
||||
// The linker specification of the different segments.
|
||||
#pragma link("procedure-callingconvention-phi-bank-5.ld")
|
||||
|
||||
// The target computer platform is the Commander X16,
|
||||
// which implements banking in ram between 0xA0000 and 0xBFFF,
|
||||
// and in rom between 0xC000 and 0xFFFF.
|
||||
#pragma target(cx16)
|
||||
|
||||
char* const SCREEN = (char*)0x0400;
|
||||
char *const SCREEN = (char *)0x0400; // Just for test purposes.
|
||||
|
||||
#pragma code_seg(stage)
|
||||
#pragma bank(ram, 1)
|
||||
#pragma code_seg(Bank1) // The sequent functions will be addressed specified by segment bank1 in the linker.
|
||||
#pragma bank(ram, 1) // The sequent functions will be banked using call method ram in bank number 1.
|
||||
|
||||
char func_bank1_a(char a, char b) {
|
||||
return a+b;
|
||||
// Function declarations
|
||||
char func_ram_bank1_a(char a, char b);
|
||||
char __bank(ram, 1) func_ram_bank1_b(char a, char b);
|
||||
char func_ram_bank1_c(char a, char b);
|
||||
char func_ram_bank1_d(char a, char b);
|
||||
char func_ram_bank1_e(char a, char b);
|
||||
char func_ram_bank1_f(char a, char b);
|
||||
char func_rom_bank2_a(char a, char b);
|
||||
char __bank(rom, 2) func_rom_bank2_b(char a, char b);
|
||||
char func_rom_bank2_c(char a, char b);
|
||||
char func_rom_bank2_d(char a, char b);
|
||||
char func_rom_bank2_e(char a, char b);
|
||||
char func_rom_bank2_f(char a, char b);
|
||||
char func_main_a(char a, char b);
|
||||
char func_main_b(char a, char b);
|
||||
|
||||
// Functional code
|
||||
|
||||
char func_ram_bank1_a(char a, char b) {
|
||||
return a + b;
|
||||
}
|
||||
|
||||
char func_bank1_c(char a, char b) {
|
||||
// this should be a near call, because the call is from the same bank.
|
||||
return func_bank1_a(a,b);
|
||||
char func_ram_bank1_c(char a, char b) {
|
||||
return func_ram_bank1_a(a, b); // Non banked call in ram bank 1.
|
||||
}
|
||||
|
||||
char func_bank1_d(char a, char b) {
|
||||
// this should be a far call, because the call is to an other bank.
|
||||
return func_bank2_a(a,b);
|
||||
char func_ram_bank1_d(char a, char b) {
|
||||
return func_rom_bank2_a(a, b); // Banked call from ram bank 1 to rom bank 2.
|
||||
}
|
||||
|
||||
#pragma code_seg(platform)
|
||||
#pragma bank(ram, 2)
|
||||
char func_ram_bank1_e(char a, char b) {
|
||||
return func_rom_bank2_b(a, b); // Banked call from ram bank 1 to rom bank 2.
|
||||
}
|
||||
|
||||
char func_bank2_a(char a, char b) {
|
||||
return a+b;
|
||||
char func_ram_bank1_f(char a, char b) {
|
||||
return func_main_a(a, b); // Non banked call from ram bank 1 to main memory.
|
||||
}
|
||||
|
||||
|
||||
char func_bank2_c(char a, char b) {
|
||||
// this should be a far call, because the call is from another bank.
|
||||
return func_bank1_a(a,b);
|
||||
#pragma code_seg(Bank2) // The sequent functions will be addressed specified by segment bank2 in the linker.
|
||||
#pragma bank(rom, 2) // The sequent functions will be banked using call method rom in bank number 2.
|
||||
|
||||
char func_rom_bank2_a(char a, char b) {
|
||||
return a + b;
|
||||
}
|
||||
|
||||
char func_bank2_d(char a, char b) {
|
||||
// this should be a near call, because the call is from the same bank.
|
||||
return func_bank2_a(a,b);
|
||||
char func_rom_bank2_c(char a, char b) {
|
||||
return func_ram_bank1_a(a, b); // Banked call from rom bank 2 to ram bank 1.
|
||||
}
|
||||
|
||||
char func_bank2_e(char a, char b) {
|
||||
// this should be a near call, because the call is from the same bank.
|
||||
return func_bank2_b(a,b);
|
||||
char func_rom_bank2_d(char a, char b) {
|
||||
return func_rom_bank2_a(a, b); // Non banked call in rom bank 2.
|
||||
}
|
||||
|
||||
char func_bank2_f(char a, char b) {
|
||||
// this should be a far call, because the call is from another bank.
|
||||
return func_bank1_b(a,b);
|
||||
char func_rom_bank2_e(char a, char b) {
|
||||
return func_rom_bank2_b(a, b); // Non Banked call in rom bank 2.
|
||||
}
|
||||
|
||||
#pragma nobank(dummy)
|
||||
|
||||
char __bank(ram, 1) func_bank1_b(char a, char b) {
|
||||
return a+b;
|
||||
char func_rom_bank2_f(char a, char b) {
|
||||
return func_main_a(a, b); // Non banked call from rom bank 2 to main memory.
|
||||
}
|
||||
|
||||
char __bank(ram, 2) func_bank2_b(char a, char b) {
|
||||
return a+b;
|
||||
|
||||
#pragma nobank(dummy) // The sequent functions will consider no banking calculations anymore.
|
||||
|
||||
// The __bank directive declares this function to be banked using call method ram in bank number 1 of banked ram.
|
||||
char __bank(ram, 1) func_ram_bank1_b(char a, char b) {
|
||||
return a + b;
|
||||
}
|
||||
|
||||
#pragma nobank(dummy)
|
||||
|
||||
char func_bank1_e(char a, char b) {
|
||||
// this should be a far call, because the call is to bank 1.
|
||||
return func_bank1_a(a,b);
|
||||
// The __bank directive declares this function to be banked using call method rom in bank number 2 of banked rom.
|
||||
char __bank(rom, 2) func_rom_bank2_b(char a, char b) {
|
||||
return a + b;
|
||||
}
|
||||
|
||||
char func_bank1_f(char a, char b) {
|
||||
// this should be a far call, because the call is to bank 2.
|
||||
return func_bank2_a(a,b);
|
||||
#pragma code_seg(Code) // The sequent functions will be addressed in the default main memory location (segment Code).
|
||||
|
||||
// Allocated in main memory.
|
||||
char func_main_a(char a, char b) {
|
||||
return func_ram_bank1_e(a, b); // Banked call to ram in bank 1 from main memory.
|
||||
}
|
||||
|
||||
#pragma code_seg(Code)
|
||||
// Allocated in main memory.
|
||||
char func_main_b(char a, char b) {
|
||||
return func_rom_bank2_e(a, b); // Banked call to rom in bank 2 from main memory.
|
||||
}
|
||||
|
||||
// Practically this means that the main() function is placed in main memory ...
|
||||
|
||||
void main(void) {
|
||||
// far call
|
||||
SCREEN[0] = func_bank1_a('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank1_b('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank1_c('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank1_d('0', 7);
|
||||
// near call
|
||||
SCREEN[0] = func_bank1_e('0', 7);
|
||||
// near call
|
||||
SCREEN[0] = func_bank1_f('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank2_a('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank2_b('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank2_c('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank2_d('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank2_e('0', 7);
|
||||
// far call
|
||||
SCREEN[0] = func_bank2_f('0', 7);
|
||||
SCREEN[0] = func_ram_bank1_a('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
SCREEN[0] = func_ram_bank1_b('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
SCREEN[0] = func_ram_bank1_c('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
SCREEN[0] = func_ram_bank1_d('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
SCREEN[0] = func_ram_bank1_e('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
SCREEN[0] = func_ram_bank1_f('0', 7); // Banked call to ram in bank 1 from main memory.
|
||||
SCREEN[0] = func_rom_bank2_a('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
SCREEN[0] = func_rom_bank2_b('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
SCREEN[0] = func_rom_bank2_c('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
SCREEN[0] = func_rom_bank2_d('0', 7); // Banked call to rom in bank 2 from main memory.
|
||||
SCREEN[0] = func_rom_bank2_e('0', 7); // banked call to rom in bank 2 from main memory.
|
||||
SCREEN[0] = func_rom_bank2_f('0', 7); // banked call to rom in bank 2 from main memory.
|
||||
SCREEN[0] = func_main_a('0', 7); // Near call in main memory from main memory.
|
||||
SCREEN[0] = func_main_b('0', 7); // Near call in main memory from main memory.
|
||||
}
|
||||
|
||||
|
|
|
|||
7
src/test/kc/procedure-callingconvention-phi-bank-5.ld
Normal file
7
src/test/kc/procedure-callingconvention-phi-bank-5.ld
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
.segmentdef Program [segments="Basic, Code, Data, Bank1, Bank2"]
|
||||
.segmentdef Basic [start=$0801]a
|
||||
.segmentdef Code [start=%P]
|
||||
.segmentdef Data [startAfter="Code"]
|
||||
.segmentdef Bank1 [start=$A000, min=$A000, max=$BFFF, align=$100]
|
||||
.segmentdef Bank2 [start=$C000, min=$C000, max=$FFFF, align=$100]
|
||||
|
||||
|
|
@ -1,268 +1,312 @@
|
|||
// Test a far call procedure with a calling convention phi
|
||||
// The linker specification of the different segments.
|
||||
.cpu _65c02
|
||||
.segmentdef Program [segments="Basic, Code, Data, stage, platform"]
|
||||
.segmentdef Basic [start=$0801]
|
||||
.segmentdef Program [segments="Basic, Code, Data, Bank1, Bank2"]
|
||||
.segmentdef Basic [start=$0801]a
|
||||
.segmentdef Code [start=$80d]
|
||||
.segmentdef Data [startAfter="Code"]
|
||||
.segmentdef stage [start=$0400, min=$0400, max=$07FF, align=$100]
|
||||
.segmentdef platform [start=$C000, min=$C000, max=$C7FF, align=$100]
|
||||
.segmentdef Bank1 [start=$A000, min=$A000, max=$BFFF, align=$100]
|
||||
.segmentdef Bank2 [start=$C000, min=$C000, max=$FFFF, align=$100]
|
||||
|
||||
|
||||
// The target computer platform is the Commander X16,
|
||||
// which implements banking in ram between 0xA0000 and 0xBFFF,
|
||||
// and in rom between 0xC000 and 0xFFFF.
|
||||
.label SCREEN = $400
|
||||
.segment Code
|
||||
// Practically this means that the main() function is placed in main memory ...
|
||||
main: {
|
||||
// func_bank1_a('0', 7)
|
||||
// func_ram_bank1_a('0', 7)
|
||||
lda #7
|
||||
ldx #'0'
|
||||
jsr $ff6e
|
||||
.byte <func_bank1_a
|
||||
.byte >func_bank1_a
|
||||
.byte <func_ram_bank1_a
|
||||
.byte >func_ram_bank1_a
|
||||
.byte 1
|
||||
// func_bank1_a('0', 7)
|
||||
// SCREEN[0] = func_bank1_a('0', 7)
|
||||
// far call
|
||||
// func_ram_bank1_a('0', 7)
|
||||
// SCREEN[0] = func_ram_bank1_a('0', 7)
|
||||
sta SCREEN
|
||||
// func_bank1_b('0', 7)
|
||||
lda #7
|
||||
ldx #'0'
|
||||
jsr func_bank1_b
|
||||
// func_bank1_b('0', 7)
|
||||
// SCREEN[0] = func_bank1_b('0', 7)
|
||||
// far call
|
||||
// func_ram_bank1_b('0', 7)
|
||||
jsr func_ram_bank1_b
|
||||
// SCREEN[0] = func_ram_bank1_b('0', 7)
|
||||
// Banked call to ram in bank 1 from main memory.
|
||||
lda #func_ram_bank1_b.return
|
||||
sta SCREEN
|
||||
// func_bank1_c('0', 7)
|
||||
// func_ram_bank1_c('0', 7)
|
||||
jsr $ff6e
|
||||
.byte <func_bank1_c
|
||||
.byte >func_bank1_c
|
||||
.byte <func_ram_bank1_c
|
||||
.byte >func_ram_bank1_c
|
||||
.byte 1
|
||||
// func_bank1_c('0', 7)
|
||||
// SCREEN[0] = func_bank1_c('0', 7)
|
||||
// far call
|
||||
// func_ram_bank1_c('0', 7)
|
||||
// SCREEN[0] = func_ram_bank1_c('0', 7)
|
||||
// Banked call to ram in bank 1 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank1_d('0', 7)
|
||||
// func_ram_bank1_d('0', 7)
|
||||
jsr $ff6e
|
||||
.byte <func_bank1_d
|
||||
.byte >func_bank1_d
|
||||
.byte <func_ram_bank1_d
|
||||
.byte >func_ram_bank1_d
|
||||
.byte 1
|
||||
// func_bank1_d('0', 7)
|
||||
// SCREEN[0] = func_bank1_d('0', 7)
|
||||
// far call
|
||||
// func_ram_bank1_d('0', 7)
|
||||
// SCREEN[0] = func_ram_bank1_d('0', 7)
|
||||
// Banked call to ram in bank 1 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank1_e('0', 7)
|
||||
jsr func_bank1_e
|
||||
// func_bank1_e('0', 7)
|
||||
// SCREEN[0] = func_bank1_e('0', 7)
|
||||
// near call
|
||||
// func_ram_bank1_e('0', 7)
|
||||
ldx #7
|
||||
lda #'0'
|
||||
jsr $ff6e
|
||||
.byte <func_ram_bank1_e
|
||||
.byte >func_ram_bank1_e
|
||||
.byte 1
|
||||
// func_ram_bank1_e('0', 7)
|
||||
// SCREEN[0] = func_ram_bank1_e('0', 7)
|
||||
// Banked call to ram in bank 1 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank1_f('0', 7)
|
||||
jsr func_bank1_f
|
||||
// func_bank1_f('0', 7)
|
||||
// SCREEN[0] = func_bank1_f('0', 7)
|
||||
// near call
|
||||
// func_ram_bank1_f('0', 7)
|
||||
jsr $ff6e
|
||||
.byte <func_ram_bank1_f
|
||||
.byte >func_ram_bank1_f
|
||||
.byte 1
|
||||
// func_ram_bank1_f('0', 7)
|
||||
// SCREEN[0] = func_ram_bank1_f('0', 7)
|
||||
// Banked call to ram in bank 1 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank2_a('0', 7)
|
||||
// func_rom_bank2_a('0', 7)
|
||||
lda #7
|
||||
ldx #'0'
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_a
|
||||
.byte >func_bank2_a
|
||||
.byte <func_rom_bank2_a
|
||||
.byte >func_rom_bank2_a
|
||||
.byte 2
|
||||
// func_bank2_a('0', 7)
|
||||
// SCREEN[0] = func_bank2_a('0', 7)
|
||||
// far call
|
||||
// func_rom_bank2_a('0', 7)
|
||||
// SCREEN[0] = func_rom_bank2_a('0', 7)
|
||||
// Banked call to ram in bank 1 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank2_b('0', 7)
|
||||
lda #7
|
||||
ldx #'0'
|
||||
jsr func_bank2_b
|
||||
// func_bank2_b('0', 7)
|
||||
// SCREEN[0] = func_bank2_b('0', 7)
|
||||
// far call
|
||||
// func_rom_bank2_b('0', 7)
|
||||
ldx #7
|
||||
lda #'0'
|
||||
jsr func_rom_bank2_b
|
||||
// func_rom_bank2_b('0', 7)
|
||||
// SCREEN[0] = func_rom_bank2_b('0', 7)
|
||||
// Banked call to rom in bank 2 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank2_c('0', 7)
|
||||
// func_rom_bank2_c('0', 7)
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_c
|
||||
.byte >func_bank2_c
|
||||
.byte <func_rom_bank2_c
|
||||
.byte >func_rom_bank2_c
|
||||
.byte 2
|
||||
// func_bank2_c('0', 7)
|
||||
// SCREEN[0] = func_bank2_c('0', 7)
|
||||
// far call
|
||||
// func_rom_bank2_c('0', 7)
|
||||
// SCREEN[0] = func_rom_bank2_c('0', 7)
|
||||
// Banked call to rom in bank 2 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank2_d('0', 7)
|
||||
// func_rom_bank2_d('0', 7)
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_d
|
||||
.byte >func_bank2_d
|
||||
.byte <func_rom_bank2_d
|
||||
.byte >func_rom_bank2_d
|
||||
.byte 2
|
||||
// func_bank2_d('0', 7)
|
||||
// SCREEN[0] = func_bank2_d('0', 7)
|
||||
// far call
|
||||
// func_rom_bank2_d('0', 7)
|
||||
// SCREEN[0] = func_rom_bank2_d('0', 7)
|
||||
// Banked call to rom in bank 2 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank2_e('0', 7)
|
||||
// func_rom_bank2_e('0', 7)
|
||||
ldx #7
|
||||
lda #'0'
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_e
|
||||
.byte >func_bank2_e
|
||||
.byte <func_rom_bank2_e
|
||||
.byte >func_rom_bank2_e
|
||||
.byte 2
|
||||
// func_bank2_e('0', 7)
|
||||
// SCREEN[0] = func_bank2_e('0', 7)
|
||||
// far call
|
||||
// func_rom_bank2_e('0', 7)
|
||||
// SCREEN[0] = func_rom_bank2_e('0', 7)
|
||||
// Banked call to rom in bank 2 from main memory.
|
||||
sta SCREEN
|
||||
// func_bank2_f('0', 7)
|
||||
// func_rom_bank2_f('0', 7)
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_f
|
||||
.byte >func_bank2_f
|
||||
.byte <func_rom_bank2_f
|
||||
.byte >func_rom_bank2_f
|
||||
.byte 2
|
||||
// func_bank2_f('0', 7)
|
||||
// SCREEN[0] = func_bank2_f('0', 7)
|
||||
// far call
|
||||
// func_rom_bank2_f('0', 7)
|
||||
// SCREEN[0] = func_rom_bank2_f('0', 7)
|
||||
// banked call to rom in bank 2 from main memory.
|
||||
sta SCREEN
|
||||
// func_main_a('0', 7)
|
||||
ldx #7
|
||||
lda #'0'
|
||||
jsr func_main_a
|
||||
// func_main_a('0', 7)
|
||||
// SCREEN[0] = func_main_a('0', 7)
|
||||
// banked call to rom in bank 2 from main memory.
|
||||
sta SCREEN
|
||||
// func_main_b('0', 7)
|
||||
jsr func_main_b
|
||||
// func_main_b('0', 7)
|
||||
// SCREEN[0] = func_main_b('0', 7)
|
||||
// Near call in main memory from main memory.
|
||||
sta SCREEN
|
||||
// }
|
||||
rts
|
||||
}
|
||||
.segment stage
|
||||
// __register(A) char func_bank1_a(__register(X) char a, __register(A) char b)
|
||||
func_bank1_a: {
|
||||
// a+b
|
||||
.segment Bank1
|
||||
// Functional code
|
||||
// __register(A) char func_ram_bank1_a(__register(X) char a, __register(A) char b)
|
||||
func_ram_bank1_a: {
|
||||
// a + b
|
||||
stx.z $ff
|
||||
clc
|
||||
adc.z $ff
|
||||
// }
|
||||
rts
|
||||
}
|
||||
.segment platform
|
||||
// __register(A) char func_bank1_b(__register(X) char a, __register(A) char b)
|
||||
func_bank1_b: {
|
||||
// a+b
|
||||
stx.z $ff
|
||||
clc
|
||||
adc.z $ff
|
||||
// }
|
||||
rts
|
||||
}
|
||||
.segment stage
|
||||
// __register(A) char func_bank1_c(char a, char b)
|
||||
func_bank1_c: {
|
||||
.segment Bank2
|
||||
// The sequent functions will consider no banking calculations anymore.
|
||||
// The __bank directive declares this function to be banked using call method ram in bank number 1 of banked ram.
|
||||
// char func_ram_bank1_b(char a, char b)
|
||||
func_ram_bank1_b: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank1_a(a,b)
|
||||
.label return = a+b
|
||||
rts
|
||||
}
|
||||
.segment Bank1
|
||||
// __register(A) char func_ram_bank1_c(char a, char b)
|
||||
func_ram_bank1_c: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_ram_bank1_a(a, b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr func_bank1_a
|
||||
// func_bank1_a(a,b)
|
||||
jsr func_ram_bank1_a
|
||||
// func_ram_bank1_a(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank1_d(char a, char b)
|
||||
func_bank1_d: {
|
||||
// __register(A) char func_ram_bank1_d(char a, char b)
|
||||
func_ram_bank1_d: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank2_a(a,b)
|
||||
// func_rom_bank2_a(a, b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_a
|
||||
.byte >func_bank2_a
|
||||
.byte <func_rom_bank2_a
|
||||
.byte >func_rom_bank2_a
|
||||
.byte 2
|
||||
// func_bank2_a(a,b)
|
||||
// func_rom_bank2_a(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
.segment platform
|
||||
// __register(A) char func_bank1_e(char a, char b)
|
||||
func_bank1_e: {
|
||||
// __register(A) char func_ram_bank1_e(__register(A) char a, __register(X) char b)
|
||||
func_ram_bank1_e: {
|
||||
// func_rom_bank2_b(a, b)
|
||||
jsr func_rom_bank2_b
|
||||
// func_rom_bank2_b(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_ram_bank1_f(char a, char b)
|
||||
func_ram_bank1_f: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank1_a(a,b)
|
||||
// func_main_a(a, b)
|
||||
ldx #b
|
||||
lda #a
|
||||
jsr func_main_a
|
||||
// func_main_a(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
.segment Bank2
|
||||
// The sequent functions will be banked using call method rom in bank number 2.
|
||||
// __register(A) char func_rom_bank2_a(__register(X) char a, __register(A) char b)
|
||||
func_rom_bank2_a: {
|
||||
// a + b
|
||||
stx.z $ff
|
||||
clc
|
||||
adc.z $ff
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// The __bank directive declares this function to be banked using call method rom in bank number 2 of banked rom.
|
||||
// __register(A) char func_rom_bank2_b(__register(A) char a, __register(X) char b)
|
||||
func_rom_bank2_b: {
|
||||
// a + b
|
||||
stx.z $ff
|
||||
clc
|
||||
adc.z $ff
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_rom_bank2_c(char a, char b)
|
||||
func_rom_bank2_c: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_ram_bank1_a(a, b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr $ff6e
|
||||
.byte <func_bank1_a
|
||||
.byte >func_bank1_a
|
||||
.byte <func_ram_bank1_a
|
||||
.byte >func_ram_bank1_a
|
||||
.byte 1
|
||||
// func_bank1_a(a,b)
|
||||
// func_ram_bank1_a(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank1_f(char a, char b)
|
||||
func_bank1_f: {
|
||||
// __register(A) char func_rom_bank2_d(char a, char b)
|
||||
func_rom_bank2_d: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank2_a(a,b)
|
||||
// func_rom_bank2_a(a, b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr func_rom_bank2_a
|
||||
// func_rom_bank2_a(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_rom_bank2_e(__register(A) char a, __register(X) char b)
|
||||
func_rom_bank2_e: {
|
||||
// func_rom_bank2_b(a, b)
|
||||
jsr func_rom_bank2_b
|
||||
// func_rom_bank2_b(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_rom_bank2_f(char a, char b)
|
||||
func_rom_bank2_f: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_main_a(a, b)
|
||||
ldx #b
|
||||
lda #a
|
||||
jsr func_main_a
|
||||
// func_main_a(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
.segment Code
|
||||
// The sequent functions will be addressed in the default main memory location (segment Code).
|
||||
// Allocated in main memory.
|
||||
// __register(A) char func_main_a(__register(A) char a, __register(X) char b)
|
||||
func_main_a: {
|
||||
// func_ram_bank1_e(a, b)
|
||||
jsr $ff6e
|
||||
.byte <func_bank2_a
|
||||
.byte >func_bank2_a
|
||||
.byte <func_ram_bank1_e
|
||||
.byte >func_ram_bank1_e
|
||||
.byte 1
|
||||
// func_ram_bank1_e(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// Allocated in main memory.
|
||||
// __register(A) char func_main_b(char a, char b)
|
||||
func_main_b: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_rom_bank2_e(a, b)
|
||||
ldx #b
|
||||
lda #a
|
||||
jsr $ff6e
|
||||
.byte <func_rom_bank2_e
|
||||
.byte >func_rom_bank2_e
|
||||
.byte 2
|
||||
// func_bank2_a(a,b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank2_a(__register(X) char a, __register(A) char b)
|
||||
func_bank2_a: {
|
||||
// a+b
|
||||
stx.z $ff
|
||||
clc
|
||||
adc.z $ff
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank2_b(__register(X) char a, __register(A) char b)
|
||||
func_bank2_b: {
|
||||
// a+b
|
||||
stx.z $ff
|
||||
clc
|
||||
adc.z $ff
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank2_c(char a, char b)
|
||||
func_bank2_c: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank1_a(a,b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr $ff6e
|
||||
.byte <func_bank1_a
|
||||
.byte >func_bank1_a
|
||||
.byte 1
|
||||
// func_bank1_a(a,b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank2_d(char a, char b)
|
||||
func_bank2_d: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank2_a(a,b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr func_bank2_a
|
||||
// func_bank2_a(a,b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank2_e(char a, char b)
|
||||
func_bank2_e: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank2_b(a,b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr func_bank2_b
|
||||
// func_bank2_b(a,b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// __register(A) char func_bank2_f(char a, char b)
|
||||
func_bank2_f: {
|
||||
.const a = '0'
|
||||
.const b = 7
|
||||
// func_bank1_b(a,b)
|
||||
lda #b
|
||||
ldx #a
|
||||
jsr func_bank1_b
|
||||
// func_bank1_b(a,b)
|
||||
// func_rom_bank2_e(a, b)
|
||||
// }
|
||||
rts
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,223 +2,266 @@
|
|||
void main()
|
||||
main: scope:[main] from
|
||||
[0] phi()
|
||||
[1] call func_bank1_a
|
||||
[2] func_bank1_a::return#10 = func_bank1_a::return#0
|
||||
[1] call func_ram_bank1_a
|
||||
[2] func_ram_bank1_a::return#4 = func_ram_bank1_a::return#0
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main
|
||||
[3] main::$0 = func_bank1_a::return#10
|
||||
[3] main::$0 = func_ram_bank1_a::return#4
|
||||
[4] *SCREEN = main::$0
|
||||
[5] call func_bank1_b
|
||||
[6] func_bank1_b::return#3 = func_bank1_b::return#1
|
||||
[5] call func_ram_bank1_b
|
||||
to:main::@2
|
||||
main::@2: scope:[main] from main::@1
|
||||
[7] main::$1 = func_bank1_b::return#3
|
||||
[8] *SCREEN = main::$1
|
||||
[9] call func_bank1_c
|
||||
[10] func_bank1_c::return#2 = func_bank1_c::return#0
|
||||
[6] *SCREEN = func_ram_bank1_b::return#0
|
||||
[7] call func_ram_bank1_c
|
||||
[8] func_ram_bank1_c::return#2 = func_ram_bank1_c::return#0
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@2
|
||||
[11] main::$2 = func_bank1_c::return#2
|
||||
[12] *SCREEN = main::$2
|
||||
[13] call func_bank1_d
|
||||
[14] func_bank1_d::return#2 = func_bank1_d::return#0
|
||||
[9] main::$2 = func_ram_bank1_c::return#2
|
||||
[10] *SCREEN = main::$2
|
||||
[11] call func_ram_bank1_d
|
||||
[12] func_ram_bank1_d::return#2 = func_ram_bank1_d::return#0
|
||||
to:main::@4
|
||||
main::@4: scope:[main] from main::@3
|
||||
[15] main::$3 = func_bank1_d::return#2
|
||||
[16] *SCREEN = main::$3
|
||||
[17] call func_bank1_e
|
||||
[18] func_bank1_e::return#2 = func_bank1_e::return#0
|
||||
[13] main::$3 = func_ram_bank1_d::return#2
|
||||
[14] *SCREEN = main::$3
|
||||
[15] call func_ram_bank1_e
|
||||
[16] func_ram_bank1_e::return#3 = func_ram_bank1_e::return#0
|
||||
to:main::@5
|
||||
main::@5: scope:[main] from main::@4
|
||||
[19] main::$4 = func_bank1_e::return#2
|
||||
[20] *SCREEN = main::$4
|
||||
[21] call func_bank1_f
|
||||
[22] func_bank1_f::return#2 = func_bank1_f::return#0
|
||||
[17] main::$4 = func_ram_bank1_e::return#3
|
||||
[18] *SCREEN = main::$4
|
||||
[19] call func_ram_bank1_f
|
||||
[20] func_ram_bank1_f::return#2 = func_ram_bank1_f::return#0
|
||||
to:main::@6
|
||||
main::@6: scope:[main] from main::@5
|
||||
[23] main::$5 = func_bank1_f::return#2
|
||||
[24] *SCREEN = main::$5
|
||||
[25] call func_bank2_a
|
||||
[26] func_bank2_a::return#10 = func_bank2_a::return#1
|
||||
[21] main::$5 = func_ram_bank1_f::return#2
|
||||
[22] *SCREEN = main::$5
|
||||
[23] call func_rom_bank2_a
|
||||
[24] func_rom_bank2_a::return#4 = func_rom_bank2_a::return#1
|
||||
to:main::@7
|
||||
main::@7: scope:[main] from main::@6
|
||||
[27] main::$6 = func_bank2_a::return#10
|
||||
[28] *SCREEN = main::$6
|
||||
[29] call func_bank2_b
|
||||
[30] func_bank2_b::return#3 = func_bank2_b::return#1
|
||||
[25] main::$6 = func_rom_bank2_a::return#4
|
||||
[26] *SCREEN = main::$6
|
||||
[27] call func_rom_bank2_b
|
||||
[28] func_rom_bank2_b::return#4 = func_rom_bank2_b::return#1
|
||||
to:main::@8
|
||||
main::@8: scope:[main] from main::@7
|
||||
[31] main::$7 = func_bank2_b::return#3
|
||||
[32] *SCREEN = main::$7
|
||||
[33] call func_bank2_c
|
||||
[34] func_bank2_c::return#2 = func_bank2_c::return#0
|
||||
[29] main::$7 = func_rom_bank2_b::return#4
|
||||
[30] *SCREEN = main::$7
|
||||
[31] call func_rom_bank2_c
|
||||
[32] func_rom_bank2_c::return#2 = func_rom_bank2_c::return#0
|
||||
to:main::@9
|
||||
main::@9: scope:[main] from main::@8
|
||||
[35] main::$8 = func_bank2_c::return#2
|
||||
[36] *SCREEN = main::$8
|
||||
[37] call func_bank2_d
|
||||
[38] func_bank2_d::return#2 = func_bank2_d::return#0
|
||||
[33] main::$8 = func_rom_bank2_c::return#2
|
||||
[34] *SCREEN = main::$8
|
||||
[35] call func_rom_bank2_d
|
||||
[36] func_rom_bank2_d::return#2 = func_rom_bank2_d::return#0
|
||||
to:main::@10
|
||||
main::@10: scope:[main] from main::@9
|
||||
[39] main::$9 = func_bank2_d::return#2
|
||||
[40] *SCREEN = main::$9
|
||||
[41] call func_bank2_e
|
||||
[42] func_bank2_e::return#2 = func_bank2_e::return#0
|
||||
[37] main::$9 = func_rom_bank2_d::return#2
|
||||
[38] *SCREEN = main::$9
|
||||
[39] call func_rom_bank2_e
|
||||
[40] func_rom_bank2_e::return#3 = func_rom_bank2_e::return#0
|
||||
to:main::@11
|
||||
main::@11: scope:[main] from main::@10
|
||||
[43] main::$10 = func_bank2_e::return#2
|
||||
[44] *SCREEN = main::$10
|
||||
[45] call func_bank2_f
|
||||
[46] func_bank2_f::return#2 = func_bank2_f::return#0
|
||||
[41] main::$10 = func_rom_bank2_e::return#3
|
||||
[42] *SCREEN = main::$10
|
||||
[43] call func_rom_bank2_f
|
||||
[44] func_rom_bank2_f::return#2 = func_rom_bank2_f::return#0
|
||||
to:main::@12
|
||||
main::@12: scope:[main] from main::@11
|
||||
[47] main::$11 = func_bank2_f::return#2
|
||||
[48] *SCREEN = main::$11
|
||||
[45] main::$11 = func_rom_bank2_f::return#2
|
||||
[46] *SCREEN = main::$11
|
||||
[47] call func_main_a
|
||||
[48] func_main_a::return#4 = func_main_a::return#2
|
||||
to:main::@13
|
||||
main::@13: scope:[main] from main::@12
|
||||
[49] main::$12 = func_main_a::return#4
|
||||
[50] *SCREEN = main::$12
|
||||
[51] call func_main_b
|
||||
[52] func_main_b::return#2 = func_main_b::return#0
|
||||
to:main::@14
|
||||
main::@14: scope:[main] from main::@13
|
||||
[53] main::$13 = func_main_b::return#2
|
||||
[54] *SCREEN = main::$13
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@12
|
||||
[49] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank1_a(char a , char b)
|
||||
func_bank1_a: scope:[func_bank1_a] from func_bank1_c func_bank1_e func_bank2_c main
|
||||
[50] func_bank1_a::b#4 = phi( func_bank1_c/func_bank1_c::b#0, func_bank1_e/func_bank1_e::b#0, func_bank2_c/func_bank2_c::b#0, main/7 )
|
||||
[50] func_bank1_a::a#4 = phi( func_bank1_c/func_bank1_c::a#0, func_bank1_e/func_bank1_e::a#0, func_bank2_c/func_bank2_c::a#0, main/'0' )
|
||||
[51] func_bank1_a::return#0 = func_bank1_a::a#4 + func_bank1_a::b#4
|
||||
to:func_bank1_a::@return
|
||||
func_bank1_a::@return: scope:[func_bank1_a] from func_bank1_a
|
||||
[52] return
|
||||
to:@return
|
||||
|
||||
char func_bank1_b(char a , char b)
|
||||
func_bank1_b: scope:[func_bank1_b] from func_bank2_f main::@1
|
||||
[53] func_bank1_b::b#2 = phi( func_bank2_f/func_bank2_f::b#0, main::@1/7 )
|
||||
[53] func_bank1_b::a#2 = phi( func_bank2_f/func_bank2_f::a#0, main::@1/'0' )
|
||||
[54] func_bank1_b::return#1 = func_bank1_b::a#2 + func_bank1_b::b#2
|
||||
to:func_bank1_b::@return
|
||||
func_bank1_b::@return: scope:[func_bank1_b] from func_bank1_b
|
||||
main::@return: scope:[main] from main::@14
|
||||
[55] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank1_c(char a , char b)
|
||||
func_bank1_c: scope:[func_bank1_c] from main::@2
|
||||
[56] phi()
|
||||
[57] call func_bank1_a
|
||||
[58] func_bank1_a::return#2 = func_bank1_a::return#0
|
||||
to:func_bank1_c::@1
|
||||
func_bank1_c::@1: scope:[func_bank1_c] from func_bank1_c
|
||||
[59] func_bank1_c::return#0 = func_bank1_a::return#2
|
||||
to:func_bank1_c::@return
|
||||
func_bank1_c::@return: scope:[func_bank1_c] from func_bank1_c::@1
|
||||
__bank(bank) char func_ram_bank1_a(char a , char b)
|
||||
func_ram_bank1_a: scope:[func_ram_bank1_a] from func_ram_bank1_c func_rom_bank2_c main
|
||||
[56] func_ram_bank1_a::b#3 = phi( func_ram_bank1_c/func_ram_bank1_c::b#0, func_rom_bank2_c/func_rom_bank2_c::b#0, main/7 )
|
||||
[56] func_ram_bank1_a::a#3 = phi( func_ram_bank1_c/func_ram_bank1_c::a#0, func_rom_bank2_c/func_rom_bank2_c::a#0, main/'0' )
|
||||
[57] func_ram_bank1_a::return#0 = func_ram_bank1_a::a#3 + func_ram_bank1_a::b#3
|
||||
to:func_ram_bank1_a::@return
|
||||
func_ram_bank1_a::@return: scope:[func_ram_bank1_a] from func_ram_bank1_a
|
||||
[58] return
|
||||
to:@return
|
||||
|
||||
char func_ram_bank1_b(char a , char b)
|
||||
func_ram_bank1_b: scope:[func_ram_bank1_b] from main::@1
|
||||
[59] phi()
|
||||
to:func_ram_bank1_b::@return
|
||||
func_ram_bank1_b::@return: scope:[func_ram_bank1_b] from func_ram_bank1_b
|
||||
[60] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank1_d(char a , char b)
|
||||
func_bank1_d: scope:[func_bank1_d] from main::@3
|
||||
__bank(bank) char func_ram_bank1_c(char a , char b)
|
||||
func_ram_bank1_c: scope:[func_ram_bank1_c] from main::@2
|
||||
[61] phi()
|
||||
[62] call func_bank2_a
|
||||
[63] func_bank2_a::return#0 = func_bank2_a::return#1
|
||||
to:func_bank1_d::@1
|
||||
func_bank1_d::@1: scope:[func_bank1_d] from func_bank1_d
|
||||
[64] func_bank1_d::return#0 = func_bank2_a::return#0
|
||||
to:func_bank1_d::@return
|
||||
func_bank1_d::@return: scope:[func_bank1_d] from func_bank1_d::@1
|
||||
[62] call func_ram_bank1_a
|
||||
[63] func_ram_bank1_a::return#2 = func_ram_bank1_a::return#0
|
||||
to:func_ram_bank1_c::@1
|
||||
func_ram_bank1_c::@1: scope:[func_ram_bank1_c] from func_ram_bank1_c
|
||||
[64] func_ram_bank1_c::return#0 = func_ram_bank1_a::return#2
|
||||
to:func_ram_bank1_c::@return
|
||||
func_ram_bank1_c::@return: scope:[func_ram_bank1_c] from func_ram_bank1_c::@1
|
||||
[65] return
|
||||
to:@return
|
||||
|
||||
char func_bank1_e(char a , char b)
|
||||
func_bank1_e: scope:[func_bank1_e] from main::@4
|
||||
__bank(bank) char func_ram_bank1_d(char a , char b)
|
||||
func_ram_bank1_d: scope:[func_ram_bank1_d] from main::@3
|
||||
[66] phi()
|
||||
[67] call func_bank1_a
|
||||
[68] func_bank1_a::return#4 = func_bank1_a::return#0
|
||||
to:func_bank1_e::@1
|
||||
func_bank1_e::@1: scope:[func_bank1_e] from func_bank1_e
|
||||
[69] func_bank1_e::return#0 = func_bank1_a::return#4
|
||||
to:func_bank1_e::@return
|
||||
func_bank1_e::@return: scope:[func_bank1_e] from func_bank1_e::@1
|
||||
[67] call func_rom_bank2_a
|
||||
[68] func_rom_bank2_a::return#0 = func_rom_bank2_a::return#1
|
||||
to:func_ram_bank1_d::@1
|
||||
func_ram_bank1_d::@1: scope:[func_ram_bank1_d] from func_ram_bank1_d
|
||||
[69] func_ram_bank1_d::return#0 = func_rom_bank2_a::return#0
|
||||
to:func_ram_bank1_d::@return
|
||||
func_ram_bank1_d::@return: scope:[func_ram_bank1_d] from func_ram_bank1_d::@1
|
||||
[70] return
|
||||
to:@return
|
||||
|
||||
char func_bank1_f(char a , char b)
|
||||
func_bank1_f: scope:[func_bank1_f] from main::@5
|
||||
[71] phi()
|
||||
[72] call func_bank2_a
|
||||
[73] func_bank2_a::return#4 = func_bank2_a::return#1
|
||||
to:func_bank1_f::@1
|
||||
func_bank1_f::@1: scope:[func_bank1_f] from func_bank1_f
|
||||
[74] func_bank1_f::return#0 = func_bank2_a::return#4
|
||||
to:func_bank1_f::@return
|
||||
func_bank1_f::@return: scope:[func_bank1_f] from func_bank1_f::@1
|
||||
[75] return
|
||||
__bank(bank) char func_ram_bank1_e(char a , char b)
|
||||
func_ram_bank1_e: scope:[func_ram_bank1_e] from func_main_a main::@4
|
||||
[71] func_ram_bank1_e::b#2 = phi( func_main_a/func_ram_bank1_e::b#0, main::@4/7 )
|
||||
[71] func_ram_bank1_e::a#2 = phi( func_main_a/func_ram_bank1_e::a#0, main::@4/'0' )
|
||||
[72] func_rom_bank2_b::a#0 = func_ram_bank1_e::a#2
|
||||
[73] func_rom_bank2_b::b#0 = func_ram_bank1_e::b#2
|
||||
[74] call func_rom_bank2_b
|
||||
[75] func_rom_bank2_b::return#0 = func_rom_bank2_b::return#1
|
||||
to:func_ram_bank1_e::@1
|
||||
func_ram_bank1_e::@1: scope:[func_ram_bank1_e] from func_ram_bank1_e
|
||||
[76] func_ram_bank1_e::return#0 = func_rom_bank2_b::return#0
|
||||
to:func_ram_bank1_e::@return
|
||||
func_ram_bank1_e::@return: scope:[func_ram_bank1_e] from func_ram_bank1_e::@1
|
||||
[77] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank2_a(char a , char b)
|
||||
func_bank2_a: scope:[func_bank2_a] from func_bank1_d func_bank1_f func_bank2_d main::@6
|
||||
[76] func_bank2_a::b#4 = phi( func_bank1_d/func_bank1_d::b#0, func_bank1_f/func_bank1_f::b#0, func_bank2_d/func_bank2_d::b#0, main::@6/7 )
|
||||
[76] func_bank2_a::a#4 = phi( func_bank1_d/func_bank1_d::a#0, func_bank1_f/func_bank1_f::a#0, func_bank2_d/func_bank2_d::a#0, main::@6/'0' )
|
||||
[77] func_bank2_a::return#1 = func_bank2_a::a#4 + func_bank2_a::b#4
|
||||
to:func_bank2_a::@return
|
||||
func_bank2_a::@return: scope:[func_bank2_a] from func_bank2_a
|
||||
[78] return
|
||||
__bank(bank) char func_ram_bank1_f(char a , char b)
|
||||
func_ram_bank1_f: scope:[func_ram_bank1_f] from main::@5
|
||||
[78] phi()
|
||||
[79] call func_main_a
|
||||
[80] func_main_a::return#0 = func_main_a::return#2
|
||||
to:func_ram_bank1_f::@1
|
||||
func_ram_bank1_f::@1: scope:[func_ram_bank1_f] from func_ram_bank1_f
|
||||
[81] func_ram_bank1_f::return#0 = func_main_a::return#0
|
||||
to:func_ram_bank1_f::@return
|
||||
func_ram_bank1_f::@return: scope:[func_ram_bank1_f] from func_ram_bank1_f::@1
|
||||
[82] return
|
||||
to:@return
|
||||
|
||||
char func_bank2_b(char a , char b)
|
||||
func_bank2_b: scope:[func_bank2_b] from func_bank2_e main::@7
|
||||
[79] func_bank2_b::b#2 = phi( func_bank2_e/func_bank2_e::b#0, main::@7/7 )
|
||||
[79] func_bank2_b::a#2 = phi( func_bank2_e/func_bank2_e::a#0, main::@7/'0' )
|
||||
[80] func_bank2_b::return#1 = func_bank2_b::a#2 + func_bank2_b::b#2
|
||||
to:func_bank2_b::@return
|
||||
func_bank2_b::@return: scope:[func_bank2_b] from func_bank2_b
|
||||
[81] return
|
||||
__bank(bank) char func_rom_bank2_a(char a , char b)
|
||||
func_rom_bank2_a: scope:[func_rom_bank2_a] from func_ram_bank1_d func_rom_bank2_d main::@6
|
||||
[83] func_rom_bank2_a::b#3 = phi( func_ram_bank1_d/func_ram_bank1_d::b#0, func_rom_bank2_d/func_rom_bank2_d::b#0, main::@6/7 )
|
||||
[83] func_rom_bank2_a::a#3 = phi( func_ram_bank1_d/func_ram_bank1_d::a#0, func_rom_bank2_d/func_rom_bank2_d::a#0, main::@6/'0' )
|
||||
[84] func_rom_bank2_a::return#1 = func_rom_bank2_a::a#3 + func_rom_bank2_a::b#3
|
||||
to:func_rom_bank2_a::@return
|
||||
func_rom_bank2_a::@return: scope:[func_rom_bank2_a] from func_rom_bank2_a
|
||||
[85] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank2_c(char a , char b)
|
||||
func_bank2_c: scope:[func_bank2_c] from main::@8
|
||||
[82] phi()
|
||||
[83] call func_bank1_a
|
||||
[84] func_bank1_a::return#3 = func_bank1_a::return#0
|
||||
to:func_bank2_c::@1
|
||||
func_bank2_c::@1: scope:[func_bank2_c] from func_bank2_c
|
||||
[85] func_bank2_c::return#0 = func_bank1_a::return#3
|
||||
to:func_bank2_c::@return
|
||||
func_bank2_c::@return: scope:[func_bank2_c] from func_bank2_c::@1
|
||||
[86] return
|
||||
char func_rom_bank2_b(char a , char b)
|
||||
func_rom_bank2_b: scope:[func_rom_bank2_b] from func_ram_bank1_e func_rom_bank2_e main::@7
|
||||
[86] func_rom_bank2_b::b#3 = phi( func_ram_bank1_e/func_rom_bank2_b::b#0, func_rom_bank2_e/func_rom_bank2_b::b#1, main::@7/7 )
|
||||
[86] func_rom_bank2_b::a#3 = phi( func_ram_bank1_e/func_rom_bank2_b::a#0, func_rom_bank2_e/func_rom_bank2_b::a#1, main::@7/'0' )
|
||||
[87] func_rom_bank2_b::return#1 = func_rom_bank2_b::a#3 + func_rom_bank2_b::b#3
|
||||
to:func_rom_bank2_b::@return
|
||||
func_rom_bank2_b::@return: scope:[func_rom_bank2_b] from func_rom_bank2_b
|
||||
[88] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank2_d(char a , char b)
|
||||
func_bank2_d: scope:[func_bank2_d] from main::@9
|
||||
[87] phi()
|
||||
[88] call func_bank2_a
|
||||
[89] func_bank2_a::return#3 = func_bank2_a::return#1
|
||||
to:func_bank2_d::@1
|
||||
func_bank2_d::@1: scope:[func_bank2_d] from func_bank2_d
|
||||
[90] func_bank2_d::return#0 = func_bank2_a::return#3
|
||||
to:func_bank2_d::@return
|
||||
func_bank2_d::@return: scope:[func_bank2_d] from func_bank2_d::@1
|
||||
[91] return
|
||||
__bank(bank) char func_rom_bank2_c(char a , char b)
|
||||
func_rom_bank2_c: scope:[func_rom_bank2_c] from main::@8
|
||||
[89] phi()
|
||||
[90] call func_ram_bank1_a
|
||||
[91] func_ram_bank1_a::return#3 = func_ram_bank1_a::return#0
|
||||
to:func_rom_bank2_c::@1
|
||||
func_rom_bank2_c::@1: scope:[func_rom_bank2_c] from func_rom_bank2_c
|
||||
[92] func_rom_bank2_c::return#0 = func_ram_bank1_a::return#3
|
||||
to:func_rom_bank2_c::@return
|
||||
func_rom_bank2_c::@return: scope:[func_rom_bank2_c] from func_rom_bank2_c::@1
|
||||
[93] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank2_e(char a , char b)
|
||||
func_bank2_e: scope:[func_bank2_e] from main::@10
|
||||
[92] phi()
|
||||
[93] call func_bank2_b
|
||||
[94] func_bank2_b::return#0 = func_bank2_b::return#1
|
||||
to:func_bank2_e::@1
|
||||
func_bank2_e::@1: scope:[func_bank2_e] from func_bank2_e
|
||||
[95] func_bank2_e::return#0 = func_bank2_b::return#0
|
||||
to:func_bank2_e::@return
|
||||
func_bank2_e::@return: scope:[func_bank2_e] from func_bank2_e::@1
|
||||
[96] return
|
||||
__bank(bank) char func_rom_bank2_d(char a , char b)
|
||||
func_rom_bank2_d: scope:[func_rom_bank2_d] from main::@9
|
||||
[94] phi()
|
||||
[95] call func_rom_bank2_a
|
||||
[96] func_rom_bank2_a::return#3 = func_rom_bank2_a::return#1
|
||||
to:func_rom_bank2_d::@1
|
||||
func_rom_bank2_d::@1: scope:[func_rom_bank2_d] from func_rom_bank2_d
|
||||
[97] func_rom_bank2_d::return#0 = func_rom_bank2_a::return#3
|
||||
to:func_rom_bank2_d::@return
|
||||
func_rom_bank2_d::@return: scope:[func_rom_bank2_d] from func_rom_bank2_d::@1
|
||||
[98] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_bank2_f(char a , char b)
|
||||
func_bank2_f: scope:[func_bank2_f] from main::@11
|
||||
[97] phi()
|
||||
[98] call func_bank1_b
|
||||
[99] func_bank1_b::return#0 = func_bank1_b::return#1
|
||||
to:func_bank2_f::@1
|
||||
func_bank2_f::@1: scope:[func_bank2_f] from func_bank2_f
|
||||
[100] func_bank2_f::return#0 = func_bank1_b::return#0
|
||||
to:func_bank2_f::@return
|
||||
func_bank2_f::@return: scope:[func_bank2_f] from func_bank2_f::@1
|
||||
[101] return
|
||||
__bank(bank) char func_rom_bank2_e(char a , char b)
|
||||
func_rom_bank2_e: scope:[func_rom_bank2_e] from func_main_b main::@10
|
||||
[99] func_rom_bank2_e::b#2 = phi( func_main_b/func_main_b::b#0, main::@10/7 )
|
||||
[99] func_rom_bank2_e::a#2 = phi( func_main_b/func_main_b::a#0, main::@10/'0' )
|
||||
[100] func_rom_bank2_b::a#1 = func_rom_bank2_e::a#2
|
||||
[101] func_rom_bank2_b::b#1 = func_rom_bank2_e::b#2
|
||||
[102] call func_rom_bank2_b
|
||||
[103] func_rom_bank2_b::return#3 = func_rom_bank2_b::return#1
|
||||
to:func_rom_bank2_e::@1
|
||||
func_rom_bank2_e::@1: scope:[func_rom_bank2_e] from func_rom_bank2_e
|
||||
[104] func_rom_bank2_e::return#0 = func_rom_bank2_b::return#3
|
||||
to:func_rom_bank2_e::@return
|
||||
func_rom_bank2_e::@return: scope:[func_rom_bank2_e] from func_rom_bank2_e::@1
|
||||
[105] return
|
||||
to:@return
|
||||
|
||||
__bank(bank) char func_rom_bank2_f(char a , char b)
|
||||
func_rom_bank2_f: scope:[func_rom_bank2_f] from main::@11
|
||||
[106] phi()
|
||||
[107] call func_main_a
|
||||
[108] func_main_a::return#1 = func_main_a::return#2
|
||||
to:func_rom_bank2_f::@1
|
||||
func_rom_bank2_f::@1: scope:[func_rom_bank2_f] from func_rom_bank2_f
|
||||
[109] func_rom_bank2_f::return#0 = func_main_a::return#1
|
||||
to:func_rom_bank2_f::@return
|
||||
func_rom_bank2_f::@return: scope:[func_rom_bank2_f] from func_rom_bank2_f::@1
|
||||
[110] return
|
||||
to:@return
|
||||
|
||||
char func_main_a(char a , char b)
|
||||
func_main_a: scope:[func_main_a] from func_ram_bank1_f func_rom_bank2_f main::@12
|
||||
[111] func_main_a::b#3 = phi( func_ram_bank1_f/func_ram_bank1_f::b#0, func_rom_bank2_f/func_rom_bank2_f::b#0, main::@12/7 )
|
||||
[111] func_main_a::a#3 = phi( func_ram_bank1_f/func_ram_bank1_f::a#0, func_rom_bank2_f/func_rom_bank2_f::a#0, main::@12/'0' )
|
||||
[112] func_ram_bank1_e::a#0 = func_main_a::a#3
|
||||
[113] func_ram_bank1_e::b#0 = func_main_a::b#3
|
||||
[114] call func_ram_bank1_e
|
||||
[115] func_ram_bank1_e::return#2 = func_ram_bank1_e::return#0
|
||||
to:func_main_a::@1
|
||||
func_main_a::@1: scope:[func_main_a] from func_main_a
|
||||
[116] func_main_a::return#2 = func_ram_bank1_e::return#2
|
||||
to:func_main_a::@return
|
||||
func_main_a::@return: scope:[func_main_a] from func_main_a::@1
|
||||
[117] return
|
||||
to:@return
|
||||
|
||||
char func_main_b(char a , char b)
|
||||
func_main_b: scope:[func_main_b] from main::@13
|
||||
[118] phi()
|
||||
[119] call func_rom_bank2_e
|
||||
[120] func_rom_bank2_e::return#2 = func_rom_bank2_e::return#0
|
||||
to:func_main_b::@1
|
||||
func_main_b::@1: scope:[func_main_b] from func_main_b
|
||||
[121] func_main_b::return#0 = func_rom_bank2_e::return#2
|
||||
to:func_main_b::@return
|
||||
func_main_b::@return: scope:[func_main_b] from func_main_b::@1
|
||||
[122] return
|
||||
to:@return
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,113 +1,137 @@
|
|||
__constant char * const SCREEN = (char *) 1024
|
||||
__bank(bank) char func_bank1_a(char a , char b)
|
||||
char func_bank1_a::a
|
||||
char func_bank1_a::a#4 // reg byte x 101.0
|
||||
char func_bank1_a::b
|
||||
char func_bank1_a::b#4 // reg byte a 101.0
|
||||
char func_bank1_a::return
|
||||
char func_bank1_a::return#0 // reg byte a 22.66666666666666
|
||||
char func_bank1_a::return#10 // reg byte a 4.0
|
||||
char func_bank1_a::return#2 // reg byte a 22.0
|
||||
char func_bank1_a::return#3 // reg byte a 22.0
|
||||
char func_bank1_a::return#4 // reg byte a 22.0
|
||||
char func_bank1_b(char a , char b)
|
||||
char func_bank1_b::a
|
||||
char func_bank1_b::a#2 // reg byte x 101.0
|
||||
char func_bank1_b::b
|
||||
char func_bank1_b::b#2 // reg byte a 101.0
|
||||
char func_bank1_b::return
|
||||
char func_bank1_b::return#0 // reg byte a 22.0
|
||||
char func_bank1_b::return#1 // reg byte a 28.5
|
||||
char func_bank1_b::return#3 // reg byte a 4.0
|
||||
__bank(bank) char func_bank1_c(char a , char b)
|
||||
char func_bank1_c::a
|
||||
__constant char func_bank1_c::a#0 = '0' // a
|
||||
char func_bank1_c::b
|
||||
__constant char func_bank1_c::b#0 = 7 // b
|
||||
char func_bank1_c::return
|
||||
char func_bank1_c::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank1_c::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_bank1_d(char a , char b)
|
||||
char func_bank1_d::a
|
||||
__constant char func_bank1_d::a#0 = '0' // a
|
||||
char func_bank1_d::b
|
||||
__constant char func_bank1_d::b#0 = 7 // b
|
||||
char func_bank1_d::return
|
||||
char func_bank1_d::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank1_d::return#2 // reg byte a 4.0
|
||||
char func_bank1_e(char a , char b)
|
||||
char func_bank1_e::a
|
||||
__constant char func_bank1_e::a#0 = '0' // a
|
||||
char func_bank1_e::b
|
||||
__constant char func_bank1_e::b#0 = 7 // b
|
||||
char func_bank1_e::return
|
||||
char func_bank1_e::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank1_e::return#2 // reg byte a 4.0
|
||||
char func_bank1_f(char a , char b)
|
||||
char func_bank1_f::a
|
||||
__constant char func_bank1_f::a#0 = '0' // a
|
||||
char func_bank1_f::b
|
||||
__constant char func_bank1_f::b#0 = 7 // b
|
||||
char func_bank1_f::return
|
||||
char func_bank1_f::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank1_f::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_bank2_a(char a , char b)
|
||||
char func_bank2_a::a
|
||||
char func_bank2_a::a#4 // reg byte x 101.0
|
||||
char func_bank2_a::b
|
||||
char func_bank2_a::b#4 // reg byte a 101.0
|
||||
char func_bank2_a::return
|
||||
char func_bank2_a::return#0 // reg byte a 22.0
|
||||
char func_bank2_a::return#1 // reg byte a 22.666666666666664
|
||||
char func_bank2_a::return#10 // reg byte a 4.0
|
||||
char func_bank2_a::return#3 // reg byte a 22.0
|
||||
char func_bank2_a::return#4 // reg byte a 22.0
|
||||
char func_bank2_b(char a , char b)
|
||||
char func_bank2_b::a
|
||||
char func_bank2_b::a#2 // reg byte x 101.0
|
||||
char func_bank2_b::b
|
||||
char func_bank2_b::b#2 // reg byte a 101.0
|
||||
char func_bank2_b::return
|
||||
char func_bank2_b::return#0 // reg byte a 22.0
|
||||
char func_bank2_b::return#1 // reg byte a 28.5
|
||||
char func_bank2_b::return#3 // reg byte a 4.0
|
||||
__bank(bank) char func_bank2_c(char a , char b)
|
||||
char func_bank2_c::a
|
||||
__constant char func_bank2_c::a#0 = '0' // a
|
||||
char func_bank2_c::b
|
||||
__constant char func_bank2_c::b#0 = 7 // b
|
||||
char func_bank2_c::return
|
||||
char func_bank2_c::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank2_c::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_bank2_d(char a , char b)
|
||||
char func_bank2_d::a
|
||||
__constant char func_bank2_d::a#0 = '0' // a
|
||||
char func_bank2_d::b
|
||||
__constant char func_bank2_d::b#0 = 7 // b
|
||||
char func_bank2_d::return
|
||||
char func_bank2_d::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank2_d::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_bank2_e(char a , char b)
|
||||
char func_bank2_e::a
|
||||
__constant char func_bank2_e::a#0 = '0' // a
|
||||
char func_bank2_e::b
|
||||
__constant char func_bank2_e::b#0 = 7 // b
|
||||
char func_bank2_e::return
|
||||
char func_bank2_e::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank2_e::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_bank2_f(char a , char b)
|
||||
char func_bank2_f::a
|
||||
__constant char func_bank2_f::a#0 = '0' // a
|
||||
char func_bank2_f::b
|
||||
__constant char func_bank2_f::b#0 = 7 // b
|
||||
char func_bank2_f::return
|
||||
char func_bank2_f::return#0 // reg byte a 4.333333333333333
|
||||
char func_bank2_f::return#2 // reg byte a 4.0
|
||||
char func_main_a(char a , char b)
|
||||
char func_main_a::a
|
||||
char func_main_a::a#3 // reg byte a 101.0
|
||||
char func_main_a::b
|
||||
char func_main_a::b#3 // reg byte x 50.5
|
||||
char func_main_a::return
|
||||
char func_main_a::return#0 // reg byte a 22.0
|
||||
char func_main_a::return#1 // reg byte a 22.0
|
||||
char func_main_a::return#2 // reg byte a 25.0
|
||||
char func_main_a::return#4 // reg byte a 4.0
|
||||
char func_main_b(char a , char b)
|
||||
char func_main_b::a
|
||||
__constant char func_main_b::a#0 = '0' // a
|
||||
char func_main_b::b
|
||||
__constant char func_main_b::b#0 = 7 // b
|
||||
char func_main_b::return
|
||||
char func_main_b::return#0 // reg byte a 4.333333333333333
|
||||
char func_main_b::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_ram_bank1_a(char a , char b)
|
||||
char func_ram_bank1_a::a
|
||||
char func_ram_bank1_a::a#3 // reg byte x 101.0
|
||||
char func_ram_bank1_a::b
|
||||
char func_ram_bank1_a::b#3 // reg byte a 101.0
|
||||
char func_ram_bank1_a::return
|
||||
char func_ram_bank1_a::return#0 // reg byte a 24.999999999999996
|
||||
char func_ram_bank1_a::return#2 // reg byte a 22.0
|
||||
char func_ram_bank1_a::return#3 // reg byte a 22.0
|
||||
char func_ram_bank1_a::return#4 // reg byte a 4.0
|
||||
char func_ram_bank1_b(char a , char b)
|
||||
char func_ram_bank1_b::a
|
||||
__constant char func_ram_bank1_b::a#0 = '0' // a
|
||||
char func_ram_bank1_b::b
|
||||
__constant char func_ram_bank1_b::b#0 = 7 // b
|
||||
char func_ram_bank1_b::return
|
||||
__constant char func_ram_bank1_b::return#0 = func_ram_bank1_b::a#0+func_ram_bank1_b::b#0 // return
|
||||
__bank(bank) char func_ram_bank1_c(char a , char b)
|
||||
char func_ram_bank1_c::a
|
||||
__constant char func_ram_bank1_c::a#0 = '0' // a
|
||||
char func_ram_bank1_c::b
|
||||
__constant char func_ram_bank1_c::b#0 = 7 // b
|
||||
char func_ram_bank1_c::return
|
||||
char func_ram_bank1_c::return#0 // reg byte a 4.333333333333333
|
||||
char func_ram_bank1_c::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_ram_bank1_d(char a , char b)
|
||||
char func_ram_bank1_d::a
|
||||
__constant char func_ram_bank1_d::a#0 = '0' // a
|
||||
char func_ram_bank1_d::b
|
||||
__constant char func_ram_bank1_d::b#0 = 7 // b
|
||||
char func_ram_bank1_d::return
|
||||
char func_ram_bank1_d::return#0 // reg byte a 4.333333333333333
|
||||
char func_ram_bank1_d::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_ram_bank1_e(char a , char b)
|
||||
char func_ram_bank1_e::a
|
||||
char func_ram_bank1_e::a#0 // reg byte a 101.0
|
||||
char func_ram_bank1_e::a#2 // reg byte a 1102.0
|
||||
char func_ram_bank1_e::b
|
||||
char func_ram_bank1_e::b#0 // reg byte x 202.0
|
||||
char func_ram_bank1_e::b#2 // reg byte x 551.0
|
||||
char func_ram_bank1_e::return
|
||||
char func_ram_bank1_e::return#0 // reg byte a 276.0
|
||||
char func_ram_bank1_e::return#2 // reg byte a 202.0
|
||||
char func_ram_bank1_e::return#3 // reg byte a 4.0
|
||||
__bank(bank) char func_ram_bank1_f(char a , char b)
|
||||
char func_ram_bank1_f::a
|
||||
__constant char func_ram_bank1_f::a#0 = '0' // a
|
||||
char func_ram_bank1_f::b
|
||||
__constant char func_ram_bank1_f::b#0 = 7 // b
|
||||
char func_ram_bank1_f::return
|
||||
char func_ram_bank1_f::return#0 // reg byte a 4.333333333333333
|
||||
char func_ram_bank1_f::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_rom_bank2_a(char a , char b)
|
||||
char func_rom_bank2_a::a
|
||||
char func_rom_bank2_a::a#3 // reg byte x 101.0
|
||||
char func_rom_bank2_a::b
|
||||
char func_rom_bank2_a::b#3 // reg byte a 101.0
|
||||
char func_rom_bank2_a::return
|
||||
char func_rom_bank2_a::return#0 // reg byte a 22.0
|
||||
char func_rom_bank2_a::return#1 // reg byte a 25.0
|
||||
char func_rom_bank2_a::return#3 // reg byte a 22.0
|
||||
char func_rom_bank2_a::return#4 // reg byte a 4.0
|
||||
char func_rom_bank2_b(char a , char b)
|
||||
char func_rom_bank2_b::a
|
||||
char func_rom_bank2_b::a#0 // reg byte a 1001.0
|
||||
char func_rom_bank2_b::a#1 // reg byte a 101.0
|
||||
char func_rom_bank2_b::a#3 // reg byte a 11103.0
|
||||
char func_rom_bank2_b::b
|
||||
char func_rom_bank2_b::b#0 // reg byte x 2002.0
|
||||
char func_rom_bank2_b::b#1 // reg byte x 202.0
|
||||
char func_rom_bank2_b::b#3 // reg byte x 11103.0
|
||||
char func_rom_bank2_b::return
|
||||
char func_rom_bank2_b::return#0 // reg byte a 2002.0
|
||||
char func_rom_bank2_b::return#1 // reg byte a 2221.0
|
||||
char func_rom_bank2_b::return#3 // reg byte a 202.0
|
||||
char func_rom_bank2_b::return#4 // reg byte a 4.0
|
||||
__bank(bank) char func_rom_bank2_c(char a , char b)
|
||||
char func_rom_bank2_c::a
|
||||
__constant char func_rom_bank2_c::a#0 = '0' // a
|
||||
char func_rom_bank2_c::b
|
||||
__constant char func_rom_bank2_c::b#0 = 7 // b
|
||||
char func_rom_bank2_c::return
|
||||
char func_rom_bank2_c::return#0 // reg byte a 4.333333333333333
|
||||
char func_rom_bank2_c::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_rom_bank2_d(char a , char b)
|
||||
char func_rom_bank2_d::a
|
||||
__constant char func_rom_bank2_d::a#0 = '0' // a
|
||||
char func_rom_bank2_d::b
|
||||
__constant char func_rom_bank2_d::b#0 = 7 // b
|
||||
char func_rom_bank2_d::return
|
||||
char func_rom_bank2_d::return#0 // reg byte a 4.333333333333333
|
||||
char func_rom_bank2_d::return#2 // reg byte a 4.0
|
||||
__bank(bank) char func_rom_bank2_e(char a , char b)
|
||||
char func_rom_bank2_e::a
|
||||
char func_rom_bank2_e::a#2 // reg byte a 101.0
|
||||
char func_rom_bank2_e::b
|
||||
char func_rom_bank2_e::b#2 // reg byte x 50.5
|
||||
char func_rom_bank2_e::return
|
||||
char func_rom_bank2_e::return#0 // reg byte a 28.5
|
||||
char func_rom_bank2_e::return#2 // reg byte a 22.0
|
||||
char func_rom_bank2_e::return#3 // reg byte a 4.0
|
||||
__bank(bank) char func_rom_bank2_f(char a , char b)
|
||||
char func_rom_bank2_f::a
|
||||
__constant char func_rom_bank2_f::a#0 = '0' // a
|
||||
char func_rom_bank2_f::b
|
||||
__constant char func_rom_bank2_f::b#0 = 7 // b
|
||||
char func_rom_bank2_f::return
|
||||
char func_rom_bank2_f::return#0 // reg byte a 4.333333333333333
|
||||
char func_rom_bank2_f::return#2 // reg byte a 4.0
|
||||
void main()
|
||||
char main::$0 // reg byte a 4.0
|
||||
char main::$1 // reg byte a 4.0
|
||||
char main::$10 // reg byte a 4.0
|
||||
char main::$11 // reg byte a 4.0
|
||||
char main::$12 // reg byte a 4.0
|
||||
char main::$13 // reg byte a 4.0
|
||||
char main::$2 // reg byte a 4.0
|
||||
char main::$3 // reg byte a 4.0
|
||||
char main::$4 // reg byte a 4.0
|
||||
|
|
@ -117,55 +141,64 @@ char main::$7 // reg byte a 4.0
|
|||
char main::$8 // reg byte a 4.0
|
||||
char main::$9 // reg byte a 4.0
|
||||
|
||||
reg byte x [ func_bank1_a::a#4 ]
|
||||
reg byte a [ func_bank1_a::b#4 ]
|
||||
reg byte x [ func_bank1_b::a#2 ]
|
||||
reg byte a [ func_bank1_b::b#2 ]
|
||||
reg byte x [ func_bank2_a::a#4 ]
|
||||
reg byte a [ func_bank2_a::b#4 ]
|
||||
reg byte x [ func_bank2_b::a#2 ]
|
||||
reg byte a [ func_bank2_b::b#2 ]
|
||||
reg byte a [ func_bank1_a::return#10 ]
|
||||
reg byte x [ func_ram_bank1_a::a#3 ]
|
||||
reg byte a [ func_ram_bank1_a::b#3 ]
|
||||
reg byte a [ func_ram_bank1_e::a#2 func_ram_bank1_e::a#0 ]
|
||||
reg byte x [ func_ram_bank1_e::b#2 func_ram_bank1_e::b#0 ]
|
||||
reg byte x [ func_rom_bank2_a::a#3 ]
|
||||
reg byte a [ func_rom_bank2_a::b#3 ]
|
||||
reg byte a [ func_rom_bank2_b::a#3 func_rom_bank2_b::a#0 func_rom_bank2_b::a#1 ]
|
||||
reg byte x [ func_rom_bank2_b::b#3 func_rom_bank2_b::b#0 func_rom_bank2_b::b#1 ]
|
||||
reg byte a [ func_rom_bank2_e::a#2 ]
|
||||
reg byte x [ func_rom_bank2_e::b#2 ]
|
||||
reg byte a [ func_main_a::a#3 ]
|
||||
reg byte x [ func_main_a::b#3 ]
|
||||
reg byte a [ func_ram_bank1_a::return#4 ]
|
||||
reg byte a [ main::$0 ]
|
||||
reg byte a [ func_bank1_b::return#3 ]
|
||||
reg byte a [ main::$1 ]
|
||||
reg byte a [ func_bank1_c::return#2 ]
|
||||
reg byte a [ func_ram_bank1_c::return#2 ]
|
||||
reg byte a [ main::$2 ]
|
||||
reg byte a [ func_bank1_d::return#2 ]
|
||||
reg byte a [ func_ram_bank1_d::return#2 ]
|
||||
reg byte a [ main::$3 ]
|
||||
reg byte a [ func_bank1_e::return#2 ]
|
||||
reg byte a [ func_ram_bank1_e::return#3 ]
|
||||
reg byte a [ main::$4 ]
|
||||
reg byte a [ func_bank1_f::return#2 ]
|
||||
reg byte a [ func_ram_bank1_f::return#2 ]
|
||||
reg byte a [ main::$5 ]
|
||||
reg byte a [ func_bank2_a::return#10 ]
|
||||
reg byte a [ func_rom_bank2_a::return#4 ]
|
||||
reg byte a [ main::$6 ]
|
||||
reg byte a [ func_bank2_b::return#3 ]
|
||||
reg byte a [ func_rom_bank2_b::return#4 ]
|
||||
reg byte a [ main::$7 ]
|
||||
reg byte a [ func_bank2_c::return#2 ]
|
||||
reg byte a [ func_rom_bank2_c::return#2 ]
|
||||
reg byte a [ main::$8 ]
|
||||
reg byte a [ func_bank2_d::return#2 ]
|
||||
reg byte a [ func_rom_bank2_d::return#2 ]
|
||||
reg byte a [ main::$9 ]
|
||||
reg byte a [ func_bank2_e::return#2 ]
|
||||
reg byte a [ func_rom_bank2_e::return#3 ]
|
||||
reg byte a [ main::$10 ]
|
||||
reg byte a [ func_bank2_f::return#2 ]
|
||||
reg byte a [ func_rom_bank2_f::return#2 ]
|
||||
reg byte a [ main::$11 ]
|
||||
reg byte a [ func_bank1_a::return#0 ]
|
||||
reg byte a [ func_bank1_b::return#1 ]
|
||||
reg byte a [ func_bank1_a::return#2 ]
|
||||
reg byte a [ func_bank1_c::return#0 ]
|
||||
reg byte a [ func_bank2_a::return#0 ]
|
||||
reg byte a [ func_bank1_d::return#0 ]
|
||||
reg byte a [ func_bank1_a::return#4 ]
|
||||
reg byte a [ func_bank1_e::return#0 ]
|
||||
reg byte a [ func_bank2_a::return#4 ]
|
||||
reg byte a [ func_bank1_f::return#0 ]
|
||||
reg byte a [ func_bank2_a::return#1 ]
|
||||
reg byte a [ func_bank2_b::return#1 ]
|
||||
reg byte a [ func_bank1_a::return#3 ]
|
||||
reg byte a [ func_bank2_c::return#0 ]
|
||||
reg byte a [ func_bank2_a::return#3 ]
|
||||
reg byte a [ func_bank2_d::return#0 ]
|
||||
reg byte a [ func_bank2_b::return#0 ]
|
||||
reg byte a [ func_bank2_e::return#0 ]
|
||||
reg byte a [ func_bank1_b::return#0 ]
|
||||
reg byte a [ func_bank2_f::return#0 ]
|
||||
reg byte a [ func_main_a::return#4 ]
|
||||
reg byte a [ main::$12 ]
|
||||
reg byte a [ func_main_b::return#2 ]
|
||||
reg byte a [ main::$13 ]
|
||||
reg byte a [ func_ram_bank1_a::return#0 ]
|
||||
reg byte a [ func_ram_bank1_a::return#2 ]
|
||||
reg byte a [ func_ram_bank1_c::return#0 ]
|
||||
reg byte a [ func_rom_bank2_a::return#0 ]
|
||||
reg byte a [ func_ram_bank1_d::return#0 ]
|
||||
reg byte a [ func_rom_bank2_b::return#0 ]
|
||||
reg byte a [ func_ram_bank1_e::return#0 ]
|
||||
reg byte a [ func_main_a::return#0 ]
|
||||
reg byte a [ func_ram_bank1_f::return#0 ]
|
||||
reg byte a [ func_rom_bank2_a::return#1 ]
|
||||
reg byte a [ func_rom_bank2_b::return#1 ]
|
||||
reg byte a [ func_ram_bank1_a::return#3 ]
|
||||
reg byte a [ func_rom_bank2_c::return#0 ]
|
||||
reg byte a [ func_rom_bank2_a::return#3 ]
|
||||
reg byte a [ func_rom_bank2_d::return#0 ]
|
||||
reg byte a [ func_rom_bank2_b::return#3 ]
|
||||
reg byte a [ func_rom_bank2_e::return#0 ]
|
||||
reg byte a [ func_main_a::return#1 ]
|
||||
reg byte a [ func_rom_bank2_f::return#0 ]
|
||||
reg byte a [ func_ram_bank1_e::return#2 ]
|
||||
reg byte a [ func_main_a::return#2 ]
|
||||
reg byte a [ func_rom_bank2_e::return#2 ]
|
||||
reg byte a [ func_main_b::return#0 ]
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user