6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-04-05 07:40:39 +00:00
Code Issues Projects Releases Wiki Activity

Moved calling convention stack handling to pass 1. Passing structs to __stackcall does not work atm.

Browse Source
This commit is contained in:
jespergravgaard 2020-03-05 09:13:52 +01:00
parent c6f81595fb
commit 797c3bbd21
27 changed files with 2261 additions and 892 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/main/java/dk/camelot64/kickc/Compiler.java
View File

@ -264,11 +264,13 @@ public class Compiler {
//getLog().append("CONTROL FLOW GRAPH (CLEANED)");
//getLog().append(program.getGraph().toString(program));
// Handle calling convention stack
new PassNCallingConventionStack(program).execute();
new Pass1ProcedureCallParameters(program).generate();
//getLog().append("CONTROL FLOW GRAPH (BEFORE LIST UNWINDING)");
//getLog().append(program.getGraph().toString(program));
new PassNUnwindLValueLists(program).execute();
//new Pass1PointifyMemoryVariables(program).execute();
//getLog().append("CONTROL FLOW GRAPH (CALL PARAMETERS)");
//getLog().append(program.getGraph().toString(program));
@ -527,9 +529,6 @@ public class Compiler {
new Pass3AddNopBeforeCallOns(program).generate();
new PassNStatementIndices(program).execute();
// Handle calling convention stack
new PassNCallingConventionStack(program).execute();
program.clearCallGraph();
program.clearStatementIndices();
program.clearStatementInfos();

1
src/main/java/dk/camelot64/kickc/model/CallingConventionStack.java
View File

@ -130,6 +130,7 @@ public class CallingConventionStack {
public static ConstantRef getStackBaseConstant(ProgramScope programScope) {
long STACK_BASE_ADDRESS = 0x103L;
Variable stackBase = Variable.createConstant("STACK_BASE", SymbolType.WORD, programScope, null, new ConstantInteger(STACK_BASE_ADDRESS, SymbolType.WORD), Scope.SEGMENT_DATA_DEFAULT);
stackBase.setExport(true);
programScope.add(stackBase);
return stackBase.getConstantRef();
}

5
src/test/java/dk/camelot64/kickc/test/TestPrograms.java
View File

@ -279,6 +279,11 @@ public class TestPrograms {
compileAndCompare("declared-memory-var-0");
}
@Test
public void testProcedureCallingConventionStack10() throws IOException, URISyntaxException {
compileAndCompare("procedure-callingconvention-stack-10", log().verboseCreateSsa());
}
@Test
public void testProcedureCallingConventionStack9() throws IOException, URISyntaxException {
compileAndCompare("procedure-callingconvention-stack-9");

35
src/test/kc/procedure-callingconvention-stack-10.kc Normal file
View File

@ -0,0 +1,35 @@
// Test a procedure with calling convention stack
// Returning and passing struct values
#pragma calling(__stackcall)
#pragma var_model(ma_zp)
const char* SCREEN = 0x0400;
char idx = 0;
struct Point {
char x;
char y;
};
void main(void) {
for(char i=0;i<5;i++) {
struct Point p = get(i);
print(p);
}
}
struct Point get(char i) {
struct Point p = { i, i/2 };
return p;
}
void print(struct Point p) {
SCREEN[idx++] = p.x;
SCREEN[idx++] = p.y;
}

19
src/test/ref/procedure-callingconvention-stack-0.cfg
View File

@ -10,22 +10,21 @@
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (byte) '0' (byte) 7
[6] callexecute plus
[7] (byte~) main::$0 ← callfinalize plus
[8] *((const byte*) SCREEN) ← (byte~) main::$0
[4] callprepare plus (byte) '0' (byte) 7
[5] callexecute plus
[6] (byte~) main::$0 ← callfinalize plus
[7] *((const byte*) SCREEN) ← (byte~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
[10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
[9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (byte) plus::return#0
[12] return (byte) plus::return#0
to:@return

148
src/test/ref/procedure-callingconvention-stack-0.log
View File

@ -1,5 +1,8 @@
Culled Empty Block (label) @1
Culled Empty Block (label) plus::@1
Calling convention STACK_CALL adding prepare/execute/finalize for (byte~) main::$0 ← call plus (byte) '0' (number) 7
Calling convention STACK_CALL replacing param((byte) plus::a) with stackidx(byte,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((byte) plus::b) with stackidx(byte,(const byte) plus::OFFSET_STACK_B)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -7,7 +10,9 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @2
(byte~) main::$0 ← call plus (byte) '0' (number) 7
callprepare plus (byte) '0' (number) 7
callexecute plus
(byte~) main::$0 ← callfinalize plus
*((const byte*) SCREEN + (number) 0) ← (byte~) main::$0
to:main::@return
main::@return: scope:[main] from main
@ -16,8 +21,8 @@ main::@return: scope:[main] from main
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
(byte) plus::a#0 ← param((byte) plus::a)
(byte) plus::b#0 ← param((byte) plus::b)
(byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
(byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
(byte~) plus::$0 ← (byte) plus::a#0 + (byte) plus::b#0
(byte) plus::return#0 ← (byte~) plus::$0
to:plus::@return
@ -38,12 +43,16 @@ SYMBOL TABLE SSA
(label) @begin
(label) @end
(const byte*) SCREEN = (byte*)(number) $400
(const word) STACK_BASE = (word) $103
(void()) main()
(byte~) main::$0
(label) main::@return
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
(byte~) plus::$0
(label) plus::@return
(const byte) plus::OFFSET_STACK_A = (byte) 1
(const byte) plus::OFFSET_STACK_B = (byte) 0
(const byte) plus::OFFSET_STACK_RETURN = (byte) 1
(byte) plus::a
(byte) plus::a#0
(byte) plus::b
@ -52,7 +61,7 @@ __stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
(byte) plus::return#0
(byte) plus::return#1
Adding number conversion cast (unumber) 7 in (byte~) main::$0 ← call plus (byte) '0' (number) 7
Adding number conversion cast (unumber) 7 in callprepare plus (byte) '0' (number) 7
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← (byte~) main::$0
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
@ -64,13 +73,14 @@ Finalized unsigned number type (byte) 0
Successful SSA optimization PassNFinalizeNumberTypeConversions
Alias (byte) plus::return#0 = (byte~) plus::$0 (byte) plus::return#1
Successful SSA optimization Pass2AliasElimination
Simplifying expression containing zero SCREEN in [1] *((const byte*) SCREEN + (byte) 0) ← (byte~) main::$0
Simplifying expression containing zero SCREEN in [3] *((const byte*) SCREEN + (byte) 0) ← (byte~) main::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) plus::OFFSET_STACK_RETURN
Successful SSA optimization PassNEliminateUnusedVars
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @3
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:2
Calls in [main] to plus:6
@ -82,10 +92,6 @@ Renumbering block @2 to @1
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Calling convention STACK_CALL adding prepare/execute/finalize for [5] (byte~) main::$0 ← call plus (byte) '0' (byte) 7
Calling convention STACK_CALL replacing param((byte) plus::a) with stackidx(byte,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((byte) plus::b) with stackidx(byte,(const byte) plus::OFFSET_STACK_B)
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
@ -100,24 +106,23 @@ FINAL CONTROL FLOW GRAPH
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (byte) '0' (byte) 7
[6] callexecute plus
[7] (byte~) main::$0 ← callfinalize plus
[8] *((const byte*) SCREEN) ← (byte~) main::$0
[4] callprepare plus (byte) '0' (byte) 7
[5] callexecute plus
[6] (byte~) main::$0 ← callfinalize plus
[7] *((const byte*) SCREEN) ← (byte~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
[10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
[9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (byte) plus::return#0
[12] return (byte) plus::return#0
to:@return
@ -166,8 +171,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -177,26 +180,26 @@ __bend:
// main
main: {
.label __0 = 2
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
lda #7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
// [6] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
pla
// [7] (byte~) main::$0 ← callfinalize plus -- vbuz1=_stackpullbyte_
// [6] (byte~) main::$0 ← callfinalize plus -- vbuz1=_stackpullbyte_
pla
sta.z __0
// [8] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuz1
// [7] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuz1
lda.z __0
sta SCREEN
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -204,19 +207,18 @@ main: {
plus: {
.const OFFSET_STACK_A = 1
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 3
.label b = 4
.label return = 5
// [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
// [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
// [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuz1=_stackidxbyte_vbuc1
// [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
// [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuz1=vbuz2_plus_vbuz3
// [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuz1=vbuz2_plus_vbuz3
lda.z a
clc
adc.z b
@ -224,8 +226,8 @@ plus: {
jmp __breturn
// plus::@return
__breturn:
// [13] return (byte) plus::return#0
// [13] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuz1
// [12] return (byte) plus::return#0
// [12] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuz1
lda.z return
tsx
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -234,20 +236,20 @@ plus: {
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [5] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:6 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:6 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [4] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:5 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:5 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Removing always clobbered register reg byte a as potential for zp[1]:3 [ plus::a#0 ]
Removing always clobbered register reg byte x as potential for zp[1]:3 [ plus::a#0 ]
Statement [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:6 [ plus::return#0 ] ) always clobbers reg byte a
Statement [13] return (byte) plus::return#0 [ ] ( main:2::plus:6 [ ] ) always clobbers reg byte x
Statement [5] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:6 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:6 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:6 [ plus::return#0 ] ) always clobbers reg byte a
Statement [13] return (byte) plus::return#0 [ ] ( main:2::plus:6 [ ] ) always clobbers reg byte x
Statement [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:5 [ plus::return#0 ] ) always clobbers reg byte a
Statement [12] return (byte) plus::return#0 [ ] ( main:2::plus:5 [ ] ) always clobbers reg byte x
Statement [4] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:5 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:5 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:5 [ plus::return#0 ] ) always clobbers reg byte a
Statement [12] return (byte) plus::return#0 [ ] ( main:2::plus:5 [ ] ) always clobbers reg byte x
Potential registers zp[1]:2 [ main::$0 ] : zp[1]:2 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:3 [ plus::a#0 ] : zp[1]:3 , reg byte y ,
Potential registers zp[1]:4 [ plus::b#0 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y ,
@ -283,8 +285,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -293,24 +293,24 @@ __bend_from___b1:
__bend:
// main
main: {
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
lda #7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
// [6] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
pla
// [7] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
// [6] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
pla
// [8] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
// [7] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
sta SCREEN
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -320,21 +320,21 @@ plus: {
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 2
// [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
// [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
// [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
// [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
// [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
// [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
clc
adc.z a
jmp __breturn
// plus::@return
__breturn:
// [13] return (byte) plus::return#0
// [13] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
// [12] return (byte) plus::return#0
// [12] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
tsx
sta STACK_BASE+OFFSET_STACK_RETURN,x
rts
@ -349,7 +349,6 @@ Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
@ -405,30 +404,29 @@ Score: 67
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
// [3] phi from @1 to @end [phi:@1->@end]
// @end
// main
main: {
// plus('0', 7)
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
lda #7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
// [6] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
pla
// [7] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
// [6] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
pla
// SCREEN[0] = plus('0', 7)
// [8] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
// [7] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
sta SCREEN
// main::@return
// }
// [9] return
// [8] return
rts
}
// plus
@ -438,21 +436,21 @@ plus: {
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 2
// [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
// [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
// [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
// [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
// return a+b;
// [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
// [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
clc
adc.z a
// plus::@return
// }
// [13] return (byte) plus::return#0
// [13] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
// [12] return (byte) plus::return#0
// [12] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
tsx
sta STACK_BASE+OFFSET_STACK_RETURN,x
rts

19
src/test/ref/procedure-callingconvention-stack-1.cfg
View File

@ -10,22 +10,21 @@
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (byte) '0' (byte) 7
[6] callexecute plus
[7] (byte~) main::$0 ← callfinalize plus
[8] *((const byte*) SCREEN) ← (byte~) main::$0
[4] callprepare plus (byte) '0' (byte) 7
[5] callexecute plus
[6] (byte~) main::$0 ← callfinalize plus
[7] *((const byte*) SCREEN) ← (byte~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
[10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
[9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (byte) plus::return#0
[12] return (byte) plus::return#0
to:@return

148
src/test/ref/procedure-callingconvention-stack-1.log
View File

@ -1,5 +1,8 @@
Culled Empty Block (label) @1
Culled Empty Block (label) plus::@1
Calling convention STACK_CALL adding prepare/execute/finalize for (byte~) main::$0 ← call plus (byte) '0' (number) 7
Calling convention STACK_CALL replacing param((byte) plus::a) with stackidx(byte,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((byte) plus::b) with stackidx(byte,(const byte) plus::OFFSET_STACK_B)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -7,7 +10,9 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @2
(byte~) main::$0 ← call plus (byte) '0' (number) 7
callprepare plus (byte) '0' (number) 7
callexecute plus
(byte~) main::$0 ← callfinalize plus
*((const byte*) SCREEN + (number) 0) ← (byte~) main::$0
to:main::@return
main::@return: scope:[main] from main
@ -16,8 +21,8 @@ main::@return: scope:[main] from main
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
(byte) plus::a#0 ← param((byte) plus::a)
(byte) plus::b#0 ← param((byte) plus::b)
(byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
(byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
(byte~) plus::$0 ← (byte) plus::a#0 + (byte) plus::b#0
(byte) plus::return#0 ← (byte~) plus::$0
to:plus::@return
@ -38,12 +43,16 @@ SYMBOL TABLE SSA
(label) @begin
(label) @end
(const byte*) SCREEN = (byte*)(number) $400
(const word) STACK_BASE = (word) $103
(void()) main()
(byte~) main::$0
(label) main::@return
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
(byte~) plus::$0
(label) plus::@return
(const byte) plus::OFFSET_STACK_A = (byte) 1
(const byte) plus::OFFSET_STACK_B = (byte) 0
(const byte) plus::OFFSET_STACK_RETURN = (byte) 1
(byte) plus::a
(byte) plus::a#0
(byte) plus::b
@ -52,7 +61,7 @@ __stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
(byte) plus::return#0
(byte) plus::return#1
Adding number conversion cast (unumber) 7 in (byte~) main::$0 ← call plus (byte) '0' (number) 7
Adding number conversion cast (unumber) 7 in callprepare plus (byte) '0' (number) 7
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← (byte~) main::$0
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
@ -64,13 +73,14 @@ Finalized unsigned number type (byte) 0
Successful SSA optimization PassNFinalizeNumberTypeConversions
Alias (byte) plus::return#0 = (byte~) plus::$0 (byte) plus::return#1
Successful SSA optimization Pass2AliasElimination
Simplifying expression containing zero SCREEN in [1] *((const byte*) SCREEN + (byte) 0) ← (byte~) main::$0
Simplifying expression containing zero SCREEN in [3] *((const byte*) SCREEN + (byte) 0) ← (byte~) main::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) plus::OFFSET_STACK_RETURN
Successful SSA optimization PassNEliminateUnusedVars
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @3
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:2
Calls in [main] to plus:6
@ -82,10 +92,6 @@ Renumbering block @2 to @1
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Calling convention STACK_CALL adding prepare/execute/finalize for [5] (byte~) main::$0 ← call plus (byte) '0' (byte) 7
Calling convention STACK_CALL replacing param((byte) plus::a) with stackidx(byte,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((byte) plus::b) with stackidx(byte,(const byte) plus::OFFSET_STACK_B)
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
@ -100,24 +106,23 @@ FINAL CONTROL FLOW GRAPH
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (byte) '0' (byte) 7
[6] callexecute plus
[7] (byte~) main::$0 ← callfinalize plus
[8] *((const byte*) SCREEN) ← (byte~) main::$0
[4] callprepare plus (byte) '0' (byte) 7
[5] callexecute plus
[6] (byte~) main::$0 ← callfinalize plus
[7] *((const byte*) SCREEN) ← (byte~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
[10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
[9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
[10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
[11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (byte) plus::return#0
[12] return (byte) plus::return#0
to:@return
@ -166,8 +171,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -177,26 +180,26 @@ __bend:
// main
main: {
.label __0 = 2
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
lda #7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
// [6] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
pla
// [7] (byte~) main::$0 ← callfinalize plus -- vbuz1=_stackpullbyte_
// [6] (byte~) main::$0 ← callfinalize plus -- vbuz1=_stackpullbyte_
pla
sta.z __0
// [8] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuz1
// [7] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuz1
lda.z __0
sta SCREEN
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -204,19 +207,18 @@ main: {
plus: {
.const OFFSET_STACK_A = 1
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 3
.label b = 4
.label return = 5
// [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
// [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
// [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuz1=_stackidxbyte_vbuc1
// [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
// [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuz1=vbuz2_plus_vbuz3
// [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuz1=vbuz2_plus_vbuz3
lda.z a
clc
adc.z b
@ -224,8 +226,8 @@ plus: {
jmp __breturn
// plus::@return
__breturn:
// [13] return (byte) plus::return#0
// [13] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuz1
// [12] return (byte) plus::return#0
// [12] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuz1
lda.z return
tsx
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -234,20 +236,20 @@ plus: {
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [5] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:6 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:6 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [4] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:5 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:5 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Removing always clobbered register reg byte a as potential for zp[1]:3 [ plus::a#0 ]
Removing always clobbered register reg byte x as potential for zp[1]:3 [ plus::a#0 ]
Statement [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:6 [ plus::return#0 ] ) always clobbers reg byte a
Statement [13] return (byte) plus::return#0 [ ] ( main:2::plus:6 [ ] ) always clobbers reg byte x
Statement [5] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:6 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:6 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:6 [ plus::return#0 ] ) always clobbers reg byte a
Statement [13] return (byte) plus::return#0 [ ] ( main:2::plus:6 [ ] ) always clobbers reg byte x
Statement [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:5 [ plus::return#0 ] ) always clobbers reg byte a
Statement [12] return (byte) plus::return#0 [ ] ( main:2::plus:5 [ ] ) always clobbers reg byte x
Statement [4] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] (byte~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:5 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:5 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 [ plus::return#0 ] ( main:2::plus:5 [ plus::return#0 ] ) always clobbers reg byte a
Statement [12] return (byte) plus::return#0 [ ] ( main:2::plus:5 [ ] ) always clobbers reg byte x
Potential registers zp[1]:2 [ main::$0 ] : zp[1]:2 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:3 [ plus::a#0 ] : zp[1]:3 , reg byte y ,
Potential registers zp[1]:4 [ plus::b#0 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y ,
@ -283,8 +285,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -293,24 +293,24 @@ __bend_from___b1:
__bend:
// main
main: {
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
lda #7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
// [6] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
pla
// [7] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
// [6] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
pla
// [8] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
// [7] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
sta SCREEN
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -320,21 +320,21 @@ plus: {
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 2
// [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
// [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
// [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
// [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
// [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
// [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
clc
adc.z a
jmp __breturn
// plus::@return
__breturn:
// [13] return (byte) plus::return#0
// [13] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
// [12] return (byte) plus::return#0
// [12] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
tsx
sta STACK_BASE+OFFSET_STACK_RETURN,x
rts
@ -349,7 +349,6 @@ Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
@ -405,30 +404,29 @@ Score: 67
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
// [3] phi from @1 to @end [phi:@1->@end]
// @end
// main
main: {
// plus('0', 7)
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(byte) plus::b#1] -- _stackpushbyte_=vbuc1
lda #7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
// [6] (byte~) main::$0 ← callfinalize plus -- _stackpullbyte_1
pla
// [7] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
// [6] (byte~) main::$0 ← callfinalize plus -- vbuaa=_stackpullbyte_
pla
// SCREEN[0] = plus('0', 7)
// [8] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
// [7] *((const byte*) SCREEN) ← (byte~) main::$0 -- _deref_pbuc1=vbuaa
sta SCREEN
// main::@return
// }
// [9] return
// [8] return
rts
}
// plus
@ -438,21 +436,21 @@ plus: {
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 2
// [10] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
// [9] (byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A) -- vbuz1=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
// [11] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
// [10] (byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B) -- vbuaa=_stackidxbyte_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
// return a+b;
// [12] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
// [11] (byte) plus::return#0 ← (byte) plus::a#0 + (byte) plus::b#0 -- vbuaa=vbuz1_plus_vbuaa
clc
adc.z a
// plus::@return
// }
// [13] return (byte) plus::return#0
// [13] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
// [12] return (byte) plus::return#0
// [12] return (byte) plus::return#0 -- _stackidxbyte_vbuc1=vbuaa
tsx
sta STACK_BASE+OFFSET_STACK_RETURN,x
rts

99
src/test/ref/procedure-callingconvention-stack-10.asm Normal file
View File

@ -0,0 +1,99 @@
// Test a procedure with calling convention stack
// Returning and passing struct values
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
.label SCREEN = $400
.const OFFSET_STRUCT_POINT_Y = 1
.const STACK_BASE = $103
.const OFFSET_STRUCT_POINT_X = 0
.label idx = 2
__bbegin:
// idx = 0
lda #0
sta.z idx
jsr main
rts
// print(byte register(A) p_x, byte register(X) p_y)
print: {
// SCREEN[idx++] = p.x
ldy.z idx
sta SCREEN,y
// SCREEN[idx++] = p.x;
inc.z idx
// SCREEN[idx++] = p.y
ldy.z idx
txa
sta SCREEN,y
// SCREEN[idx++] = p.y;
inc.z idx
// }
rts
}
// get(byte register(X) i)
get: {
.const OFFSET_STACK_I = 0
.const OFFSET_STACK_RETURN = 0
.label p = 8
tsx
lda STACK_BASE+OFFSET_STACK_I,x
tax
// i/2
txa
lsr
// p = { i, i/2 }
stx.z p
sta p+OFFSET_STRUCT_POINT_Y
// return p;
txa
ldy p+OFFSET_STRUCT_POINT_Y
// }
tsx
sta STACK_BASE+OFFSET_STACK_RETURN+OFFSET_STRUCT_POINT_X,x
tya
tsx
sta STACK_BASE+OFFSET_STACK_RETURN+OFFSET_STRUCT_POINT_Y,x
rts
}
main: {
.label i = 3
.label p = 6
.label __1_x = 4
.label __1_y = 5
// i=0
lda #0
sta.z i
__b1:
// for(char i=0;i<5;i++)
lda.z i
cmp #5
bcc __b2
// }
rts
__b2:
// get(i)
lda.z i
pha
pha
jsr get
pla
sta.z __1_x
pla
sta.z __1_y
// p = get(i)
lda.z __1_x
sta.z p
lda.z __1_y
sta p+OFFSET_STRUCT_POINT_Y
// print(p)
lda.z p
pha
lda p+OFFSET_STRUCT_POINT_Y
pha
jsr print
pla
pla
// for(char i=0;i<5;i++)
inc.z i
jmp __b1
}

58
src/test/ref/procedure-callingconvention-stack-10.cfg Normal file
View File

@ -0,0 +1,58 @@
@begin: scope:[] from
[0] (byte) idx ← (byte) 0
to:@1
@1: scope:[] from @begin
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[4] phi()
__stackcall (void()) print((byte) print::p_x , (byte) print::p_y)
print: scope:[print] from
[5] (byte) print::p_y#0 ← phi( )
[5] (byte) print::p_x#0 ← phi( )
[6] *((const byte*) SCREEN + (byte) idx) ← (byte) print::p_x#0
[7] (byte) idx ← ++ (byte) idx
[8] *((const byte*) SCREEN + (byte) idx) ← (byte) print::p_y#0
[9] (byte) idx ← ++ (byte) idx
to:print::@return
print::@return: scope:[print] from print
[10] return
to:@return
__stackcall (struct Point()) get((byte) get::i)
get: scope:[get] from
[11] (byte) get::i#0 ← stackidx(byte,(const byte) get::OFFSET_STACK_I)
[12] (byte~) get::$0 ← (byte) get::i#0 >> (byte) 1
[13] *((byte*)&(struct Point) get::p) ← (byte) get::i#0
[14] *((byte*)&(struct Point) get::p+(const byte) OFFSET_STRUCT_POINT_Y) ← (byte~) get::$0
[15] (byte) get::return_x#0 ← *((byte*)&(struct Point) get::p)
[16] (byte) get::return_y#0 ← *((byte*)&(struct Point) get::p+(const byte) OFFSET_STRUCT_POINT_Y)
to:get::@return
get::@return: scope:[get] from get
[17] return { (byte) get::return_x#0, (byte) get::return_y#0 }
to:@return
__stackcall (void()) main()
main: scope:[main] from
[18] (byte) main::i ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@2
[19] if((byte) main::i<(byte) 5) goto main::@2
to:main::@return
main::@return: scope:[main] from main::@1
[20] return
to:@return
main::@2: scope:[main] from main::@1
[21] callprepare get (byte) main::i
[22] callexecute get
[23] { (byte~) main::$1_x, (byte~) main::$1_y } ← callfinalize get
[24] *((byte*)&(struct Point) main::p) ← (byte~) main::$1_x
[25] *((byte*)&(struct Point) main::p+(const byte) OFFSET_STRUCT_POINT_Y) ← (byte~) main::$1_y
[26] callprepare print *((byte*)&(struct Point) main::p) *((byte*)&(struct Point) main::p+(const byte) OFFSET_STRUCT_POINT_Y)
[27] callexecute print
[28] callfinalize print
[29] (byte) main::i ← ++ (byte) main::i
to:main::@1

1164
src/test/ref/procedure-callingconvention-stack-10.log Normal file
View File

File diff suppressed because it is too large Load Diff

50
src/test/ref/procedure-callingconvention-stack-10.sym Normal file
View File

@ -0,0 +1,50 @@
(label) @1
(label) @begin
(label) @end
(const byte) OFFSET_STRUCT_POINT_X = (byte) 0
(const byte) OFFSET_STRUCT_POINT_Y = (byte) 1
(byte) Point::x loadstore
(byte) Point::y loadstore
(const byte*) SCREEN = (byte*) 1024
(const word) STACK_BASE = (word) $103
__stackcall (struct Point()) get((byte) get::i)
(byte~) get::$0 reg byte a 2.0
(label) get::@return
(const byte) get::OFFSET_STACK_I = (byte) 0
(const byte) get::OFFSET_STACK_RETURN = (byte) 0
(byte) get::i
(byte) get::i#0 reg byte x 3.0
(struct Point) get::p loadstore zp[2]:8
(struct Point) get::return
(byte) get::return_x
(byte) get::return_x#0 reg byte a 1.0
(byte) get::return_y
(byte) get::return_y#0 reg byte y 2.0
(byte) idx loadstore zp[1]:2 0.7368421052631579
__stackcall (void()) main()
(byte~) main::$1_x zp[1]:4 0.8461538461538461
(byte~) main::$1_y zp[1]:5 0.8461538461538461
(label) main::@1
(label) main::@2
(label) main::@return
(byte) main::i loadstore zp[1]:3 3.1818181818181817
(struct Point) main::p loadstore zp[2]:6
__stackcall (void()) print((byte) print::p_x , (byte) print::p_y)
(label) print::@return
(byte) print::p_x
(byte) print::p_x#0 reg byte a 2.0
(byte) print::p_y
(byte) print::p_y#0 reg byte x 0.6666666666666666
reg byte a [ print::p_x#0 ]
reg byte x [ print::p_y#0 ]
zp[1]:2 [ idx ]
reg byte x [ get::i#0 ]
reg byte a [ get::$0 ]
reg byte a [ get::return_x#0 ]
reg byte y [ get::return_y#0 ]
zp[1]:3 [ main::i ]
zp[1]:4 [ main::$1_x ]
zp[1]:5 [ main::$1_y ]
zp[2]:6 [ main::p ]
zp[2]:8 [ get::p ]

19
src/test/ref/procedure-callingconvention-stack-2.cfg
View File

@ -10,22 +10,21 @@
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (word) $1234 (word) $2345
[6] callexecute plus
[7] (word~) main::$0 ← callfinalize plus
[8] *((const word*) SCREEN) ← (word~) main::$0
[4] callprepare plus (word) $1234 (word) $2345
[5] callexecute plus
[6] (word~) main::$0 ← callfinalize plus
[7] *((const word*) SCREEN) ← (word~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (word()) plus((word) plus::a , (word) plus::b)
plus: scope:[plus] from
[10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
[9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (word) plus::return#0
[12] return (word) plus::return#0
to:@return

141
src/test/ref/procedure-callingconvention-stack-2.log
View File

@ -1,6 +1,9 @@
Fixing pointer array-indexing *((const word*) SCREEN + (number) 0)
Culled Empty Block (label) @1
Culled Empty Block (label) plus::@1
Calling convention STACK_CALL adding prepare/execute/finalize for (word~) main::$0 ← call plus (number) $1234 (number) $2345
Calling convention STACK_CALL replacing param((word) plus::a) with stackidx(word,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((word) plus::b) with stackidx(word,(const byte) plus::OFFSET_STACK_B)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -8,7 +11,9 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @2
(word~) main::$0 ← call plus (number) $1234 (number) $2345
callprepare plus (number) $1234 (number) $2345
callexecute plus
(word~) main::$0 ← callfinalize plus
(number~) main::$1 ← (number) 0 * (const byte) SIZEOF_WORD
*((const word*) SCREEN + (number~) main::$1) ← (word~) main::$0
to:main::@return
@ -18,8 +23,8 @@ main::@return: scope:[main] from main
__stackcall (word()) plus((word) plus::a , (word) plus::b)
plus: scope:[plus] from
(word) plus::a#0 ← param((word) plus::a)
(word) plus::b#0 ← param((word) plus::b)
(word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
(word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
(word~) plus::$0 ← (word) plus::a#0 + (word) plus::b#0
(word) plus::return#0 ← (word~) plus::$0
to:plus::@return
@ -41,6 +46,7 @@ SYMBOL TABLE SSA
(label) @end
(const word*) SCREEN = (word*)(number) $400
(const byte) SIZEOF_WORD = (byte) 2
(const word) STACK_BASE = (word) $103
(void()) main()
(word~) main::$0
(number~) main::$1
@ -48,6 +54,9 @@ SYMBOL TABLE SSA
__stackcall (word()) plus((word) plus::a , (word) plus::b)
(word~) plus::$0
(label) plus::@return
(const byte) plus::OFFSET_STACK_A = (byte) 2
(const byte) plus::OFFSET_STACK_B = (byte) 0
(const byte) plus::OFFSET_STACK_RETURN = (byte) 2
(word) plus::a
(word) plus::a#0
(word) plus::b
@ -56,8 +65,8 @@ __stackcall (word()) plus((word) plus::a , (word) plus::b)
(word) plus::return#0
(word) plus::return#1
Adding number conversion cast (unumber) $1234 in (word~) main::$0 ← call plus (number) $1234 (number) $2345
Adding number conversion cast (unumber) $2345 in (word~) main::$0 ← call plus (unumber)(number) $1234 (number) $2345
Adding number conversion cast (unumber) $1234 in callprepare plus (number) $1234 (number) $2345
Adding number conversion cast (unumber) $2345 in callprepare plus (unumber)(number) $1234 (number) $2345
Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_WORD
Successful SSA optimization PassNAddNumberTypeConversions
@ -73,22 +82,22 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) main::$1 ← (byte) 0 * (const byte) SIZEOF_WORD
Alias (word) plus::return#0 = (word~) plus::$0 (word) plus::return#1
Successful SSA optimization Pass2AliasElimination
Constant right-side identified [1] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_WORD
Constant right-side identified [3] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_WORD
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$1 = 0*SIZEOF_WORD
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_WORD in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero SCREEN in [2] *((const word*) SCREEN + (const byte) main::$1) ← (word~) main::$0
Simplifying expression containing zero SCREEN in [4] *((const word*) SCREEN + (const byte) main::$1) ← (word~) main::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) main::$1
Eliminating unused constant (const byte) plus::OFFSET_STACK_RETURN
Eliminating unused constant (const byte) SIZEOF_WORD
Successful SSA optimization PassNEliminateUnusedVars
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @3
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:2
Calls in [main] to plus:6
@ -100,10 +109,6 @@ Renumbering block @2 to @1
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Calling convention STACK_CALL adding prepare/execute/finalize for [5] (word~) main::$0 ← call plus (word) $1234 (word) $2345
Calling convention STACK_CALL replacing param((word) plus::a) with stackidx(word,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((word) plus::b) with stackidx(word,(const byte) plus::OFFSET_STACK_B)
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
@ -118,24 +123,23 @@ FINAL CONTROL FLOW GRAPH
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (word) $1234 (word) $2345
[6] callexecute plus
[7] (word~) main::$0 ← callfinalize plus
[8] *((const word*) SCREEN) ← (word~) main::$0
[4] callprepare plus (word) $1234 (word) $2345
[5] callexecute plus
[6] (word~) main::$0 ← callfinalize plus
[7] *((const word*) SCREEN) ← (word~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (word()) plus((word) plus::a , (word) plus::b)
plus: scope:[plus] from
[10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
[9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (word) plus::return#0
[12] return (word) plus::return#0
to:@return
@ -184,8 +188,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -195,27 +197,27 @@ __bend:
// main
main: {
.label __0 = 2
// [5] callprepare plus (word) $1234 (word) $2345 [(word) plus::a#0] -- _stackpushword_=vwuc1
// [4] callprepare plus (word) $1234 (word) $2345 [(word) plus::a#0] -- _stackpushword_=vwuc1
lda #>$1234
pha
lda #<$1234
pha
// [5] callprepare plus (word) $1234 (word) $2345 [(word) plus::b#1] -- _stackpushword_=vwuc1
// [4] callprepare plus (word) $1234 (word) $2345 [(word) plus::b#1] -- _stackpushword_=vwuc1
lda #>$2345
pha
lda #<$2345
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
// [6] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
pla
pla
// [7] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
// [6] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
pla
sta.z __0
pla
sta.z __0+1
// [8] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
// [7] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN
lda.z __0+1
@ -223,7 +225,7 @@ main: {
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -231,23 +233,22 @@ main: {
plus: {
.const OFFSET_STACK_A = 2
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 2
.label a = 4
.label b = 6
.label return = 8
// [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
// [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
lda STACK_BASE+OFFSET_STACK_A+1,x
sta.z a+1
// [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
// [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
lda STACK_BASE+OFFSET_STACK_B+1,x
sta.z b+1
// [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz2_plus_vwuz3
// [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz2_plus_vwuz3
lda.z a
clc
adc.z b
@ -258,8 +259,8 @@ plus: {
jmp __breturn
// plus::@return
__breturn:
// [13] return (word) plus::return#0
// [13] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
// [12] return (word) plus::return#0
// [12] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -270,13 +271,13 @@ plus: {
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [5] callprepare plus (word) $1234 (word) $2345 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (word~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [8] *((const word*) SCREEN) ← (word~) main::$0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:6 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:6 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 [ plus::return#0 ] ( main:2::plus:6 [ plus::return#0 ] ) always clobbers reg byte a
Statement [13] return (word) plus::return#0 [ ] ( main:2::plus:6 [ ] ) always clobbers reg byte a reg byte x
Statement [4] callprepare plus (word) $1234 (word) $2345 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] (word~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [7] *((const word*) SCREEN) ← (word~) main::$0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:5 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:5 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 [ plus::return#0 ] ( main:2::plus:5 [ plus::return#0 ] ) always clobbers reg byte a
Statement [12] return (word) plus::return#0 [ ] ( main:2::plus:5 [ ] ) always clobbers reg byte a reg byte x
Potential registers zp[2]:2 [ main::$0 ] : zp[2]:2 ,
Potential registers zp[2]:4 [ plus::a#0 ] : zp[2]:4 ,
Potential registers zp[2]:6 [ plus::b#0 ] : zp[2]:6 ,
@ -313,8 +314,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -324,27 +323,27 @@ __bend:
// main
main: {
.label __0 = 2
// [5] callprepare plus (word) $1234 (word) $2345 [(word) plus::a#0] -- _stackpushword_=vwuc1
// [4] callprepare plus (word) $1234 (word) $2345 [(word) plus::a#0] -- _stackpushword_=vwuc1
lda #>$1234
pha
lda #<$1234
pha
// [5] callprepare plus (word) $1234 (word) $2345 [(word) plus::b#1] -- _stackpushword_=vwuc1
// [4] callprepare plus (word) $1234 (word) $2345 [(word) plus::b#1] -- _stackpushword_=vwuc1
lda #>$2345
pha
lda #<$2345
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
// [6] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
pla
pla
// [7] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
// [6] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
pla
sta.z __0
pla
sta.z __0+1
// [8] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
// [7] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN
lda.z __0+1
@ -352,7 +351,7 @@ main: {
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -364,19 +363,19 @@ plus: {
.label a = 2
.label b = 4
.label return = 2
// [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
// [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
lda STACK_BASE+OFFSET_STACK_A+1,x
sta.z a+1
// [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
// [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
lda STACK_BASE+OFFSET_STACK_B+1,x
sta.z b+1
// [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
// [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
lda.z return
clc
adc.z b
@ -387,8 +386,8 @@ plus: {
jmp __breturn
// plus::@return
__breturn:
// [13] return (word) plus::return#0
// [13] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
// [12] return (word) plus::return#0
// [12] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -406,7 +405,6 @@ Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
@ -460,42 +458,41 @@ Score: 146
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
// [3] phi from @1 to @end [phi:@1->@end]
// @end
// main
main: {
.label __0 = 2
// plus(0x1234, 0x2345)
// [5] callprepare plus (word) $1234 (word) $2345 [(word) plus::a#0] -- _stackpushword_=vwuc1
// [4] callprepare plus (word) $1234 (word) $2345 [(word) plus::a#0] -- _stackpushword_=vwuc1
lda #>$1234
pha
lda #<$1234
pha
// [5] callprepare plus (word) $1234 (word) $2345 [(word) plus::b#1] -- _stackpushword_=vwuc1
// [4] callprepare plus (word) $1234 (word) $2345 [(word) plus::b#1] -- _stackpushword_=vwuc1
lda #>$2345
pha
lda #<$2345
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
// [6] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
pla
pla
// [7] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
// [6] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
pla
sta.z __0
pla
sta.z __0+1
// SCREEN[0] = plus(0x1234, 0x2345)
// [8] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
// [7] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN
lda.z __0+1
sta SCREEN+1
// main::@return
// }
// [9] return
// [8] return
rts
}
// plus
@ -507,20 +504,20 @@ plus: {
.label a = 2
.label b = 4
.label return = 2
// [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
// [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
lda STACK_BASE+OFFSET_STACK_A+1,x
sta.z a+1
// [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
// [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
lda STACK_BASE+OFFSET_STACK_B+1,x
sta.z b+1
// return a+b;
// [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
// [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
lda.z return
clc
adc.z b
@ -530,8 +527,8 @@ plus: {
sta.z return+1
// plus::@return
// }
// [13] return (word) plus::return#0
// [13] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
// [12] return (word) plus::return#0
// [12] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x

19
src/test/ref/procedure-callingconvention-stack-3.cfg
View File

@ -10,22 +10,21 @@
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (byte) '0' (byte) 7
[6] callexecute plus
[7] (word~) main::$0 ← callfinalize plus
[8] *((const word*) SCREEN) ← (word~) main::$0
[4] callprepare plus (byte) '0' (byte) 7
[5] callexecute plus
[6] (word~) main::$0 ← callfinalize plus
[7] *((const word*) SCREEN) ← (word~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (word()) plus((word) plus::a , (word) plus::b)
plus: scope:[plus] from
[10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
[9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (word) plus::return#0
[12] return (word) plus::return#0
to:@return

139
src/test/ref/procedure-callingconvention-stack-3.log
View File

@ -1,6 +1,9 @@
Fixing pointer array-indexing *((const word*) SCREEN + (number) 0)
Culled Empty Block (label) @1
Culled Empty Block (label) plus::@1
Calling convention STACK_CALL adding prepare/execute/finalize for (word~) main::$0 ← call plus (byte) '0' (number) 7
Calling convention STACK_CALL replacing param((word) plus::a) with stackidx(word,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((word) plus::b) with stackidx(word,(const byte) plus::OFFSET_STACK_B)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -8,7 +11,9 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @2
(word~) main::$0 ← call plus (byte) '0' (number) 7
callprepare plus (byte) '0' (number) 7
callexecute plus
(word~) main::$0 ← callfinalize plus
(number~) main::$1 ← (number) 0 * (const byte) SIZEOF_WORD
*((const word*) SCREEN + (number~) main::$1) ← (word~) main::$0
to:main::@return
@ -18,8 +23,8 @@ main::@return: scope:[main] from main
__stackcall (word()) plus((word) plus::a , (word) plus::b)
plus: scope:[plus] from
(word) plus::a#0 ← param((word) plus::a)
(word) plus::b#0 ← param((word) plus::b)
(word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
(word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
(word~) plus::$0 ← (word) plus::a#0 + (word) plus::b#0
(word) plus::return#0 ← (word~) plus::$0
to:plus::@return
@ -41,6 +46,7 @@ SYMBOL TABLE SSA
(label) @end
(const word*) SCREEN = (word*)(number) $400
(const byte) SIZEOF_WORD = (byte) 2
(const word) STACK_BASE = (word) $103
(void()) main()
(word~) main::$0
(number~) main::$1
@ -48,6 +54,9 @@ SYMBOL TABLE SSA
__stackcall (word()) plus((word) plus::a , (word) plus::b)
(word~) plus::$0
(label) plus::@return
(const byte) plus::OFFSET_STACK_A = (byte) 2
(const byte) plus::OFFSET_STACK_B = (byte) 0
(const byte) plus::OFFSET_STACK_RETURN = (byte) 2
(word) plus::a
(word) plus::a#0
(word) plus::b
@ -56,7 +65,7 @@ __stackcall (word()) plus((word) plus::a , (word) plus::b)
(word) plus::return#0
(word) plus::return#1
Adding number conversion cast (unumber) 7 in (word~) main::$0 ← call plus (byte) '0' (number) 7
Adding number conversion cast (unumber) 7 in callprepare plus (byte) '0' (number) 7
Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_WORD
Successful SSA optimization PassNAddNumberTypeConversions
@ -70,22 +79,22 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) main::$1 ← (byte) 0 * (const byte) SIZEOF_WORD
Alias (word) plus::return#0 = (word~) plus::$0 (word) plus::return#1
Successful SSA optimization Pass2AliasElimination
Constant right-side identified [1] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_WORD
Constant right-side identified [3] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_WORD
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$1 = 0*SIZEOF_WORD
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_WORD in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero SCREEN in [2] *((const word*) SCREEN + (const byte) main::$1) ← (word~) main::$0
Simplifying expression containing zero SCREEN in [4] *((const word*) SCREEN + (const byte) main::$1) ← (word~) main::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) main::$1
Eliminating unused constant (const byte) plus::OFFSET_STACK_RETURN
Eliminating unused constant (const byte) SIZEOF_WORD
Successful SSA optimization PassNEliminateUnusedVars
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @3
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:2
Calls in [main] to plus:6
@ -97,10 +106,6 @@ Renumbering block @2 to @1
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Calling convention STACK_CALL adding prepare/execute/finalize for [5] (word~) main::$0 ← call plus (byte) '0' (byte) 7
Calling convention STACK_CALL replacing param((word) plus::a) with stackidx(word,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((word) plus::b) with stackidx(word,(const byte) plus::OFFSET_STACK_B)
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
@ -115,24 +120,23 @@ FINAL CONTROL FLOW GRAPH
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare plus (byte) '0' (byte) 7
[6] callexecute plus
[7] (word~) main::$0 ← callfinalize plus
[8] *((const word*) SCREEN) ← (word~) main::$0
[4] callprepare plus (byte) '0' (byte) 7
[5] callexecute plus
[6] (word~) main::$0 ← callfinalize plus
[7] *((const word*) SCREEN) ← (word~) main::$0
to:main::@return
main::@return: scope:[main] from main
[9] return
[8] return
to:@return
__stackcall (word()) plus((word) plus::a , (word) plus::b)
plus: scope:[plus] from
[10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
[9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A)
[10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B)
[11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0
to:plus::@return
plus::@return: scope:[plus] from plus
[13] return (word) plus::return#0
[12] return (word) plus::return#0
to:@return
@ -184,8 +188,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -195,27 +197,27 @@ __bend:
// main
main: {
.label __0 = 2
// [5] callprepare plus (byte) '0' (byte) 7 [(word) plus::a#0] -- _stackpushword_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(word) plus::a#0] -- _stackpushword_=vbuc1
lda #0
pha
lda #<'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(word) plus::b#1] -- _stackpushword_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(word) plus::b#1] -- _stackpushword_=vbuc1
lda #0
pha
lda #<7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
// [6] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
pla
pla
// [7] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
// [6] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
pla
sta.z __0
pla
sta.z __0+1
// [8] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
// [7] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN
lda.z __0+1
@ -223,7 +225,7 @@ main: {
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -231,23 +233,22 @@ main: {
plus: {
.const OFFSET_STACK_A = 2
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 2
.label a = 4
.label b = 6
.label return = 8
// [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
// [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
lda STACK_BASE+OFFSET_STACK_A+1,x
sta.z a+1
// [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
// [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
lda STACK_BASE+OFFSET_STACK_B+1,x
sta.z b+1
// [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz2_plus_vwuz3
// [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz2_plus_vwuz3
lda.z a
clc
adc.z b
@ -258,8 +259,8 @@ plus: {
jmp __breturn
// plus::@return
__breturn:
// [13] return (word) plus::return#0
// [13] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
// [12] return (word) plus::return#0
// [12] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -270,13 +271,13 @@ plus: {
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [5] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] (word~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [8] *((const word*) SCREEN) ← (word~) main::$0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:6 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:6 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 [ plus::return#0 ] ( main:2::plus:6 [ plus::return#0 ] ) always clobbers reg byte a
Statement [13] return (word) plus::return#0 [ ] ( main:2::plus:6 [ ] ) always clobbers reg byte a reg byte x
Statement [4] callprepare plus (byte) '0' (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] (word~) main::$0 ← callfinalize plus [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [7] *((const word*) SCREEN) ← (word~) main::$0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) [ plus::a#0 ] ( main:2::plus:5 [ plus::a#0 ] ) always clobbers reg byte a reg byte x
Statement [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) [ plus::a#0 plus::b#0 ] ( main:2::plus:5 [ plus::a#0 plus::b#0 ] ) always clobbers reg byte a reg byte x
Statement [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 [ plus::return#0 ] ( main:2::plus:5 [ plus::return#0 ] ) always clobbers reg byte a
Statement [12] return (word) plus::return#0 [ ] ( main:2::plus:5 [ ] ) always clobbers reg byte a reg byte x
Potential registers zp[2]:2 [ main::$0 ] : zp[2]:2 ,
Potential registers zp[2]:4 [ plus::a#0 ] : zp[2]:4 ,
Potential registers zp[2]:6 [ plus::b#0 ] : zp[2]:6 ,
@ -316,8 +317,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -327,27 +326,27 @@ __bend:
// main
main: {
.label __0 = 2
// [5] callprepare plus (byte) '0' (byte) 7 [(word) plus::a#0] -- _stackpushword_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(word) plus::a#0] -- _stackpushword_=vbuc1
lda #0
pha
lda #<'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(word) plus::b#1] -- _stackpushword_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(word) plus::b#1] -- _stackpushword_=vbuc1
lda #0
pha
lda #<7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
// [6] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
pla
pla
// [7] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
// [6] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
pla
sta.z __0
pla
sta.z __0+1
// [8] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
// [7] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN
lda.z __0+1
@ -355,7 +354,7 @@ main: {
jmp __breturn
// main::@return
__breturn:
// [9] return
// [8] return
rts
}
// plus
@ -367,19 +366,19 @@ plus: {
.label a = 2
.label b = 4
.label return = 2
// [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
// [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
lda STACK_BASE+OFFSET_STACK_A+1,x
sta.z a+1
// [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
// [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
lda STACK_BASE+OFFSET_STACK_B+1,x
sta.z b+1
// [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
// [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
lda.z return
clc
adc.z b
@ -390,8 +389,8 @@ plus: {
jmp __breturn
// plus::@return
__breturn:
// [13] return (word) plus::return#0
// [13] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
// [12] return (word) plus::return#0
// [12] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -409,7 +408,6 @@ Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
@ -466,42 +464,41 @@ Score: 146
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
// [3] phi from @1 to @end [phi:@1->@end]
// @end
// main
main: {
.label __0 = 2
// plus('0', 7)
// [5] callprepare plus (byte) '0' (byte) 7 [(word) plus::a#0] -- _stackpushword_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(word) plus::a#0] -- _stackpushword_=vbuc1
lda #0
pha
lda #<'0'
pha
// [5] callprepare plus (byte) '0' (byte) 7 [(word) plus::b#1] -- _stackpushword_=vbuc1
// [4] callprepare plus (byte) '0' (byte) 7 [(word) plus::b#1] -- _stackpushword_=vbuc1
lda #0
pha
lda #<7
pha
// [6] callexecute plus -- jsr
// [5] callexecute plus -- jsr
jsr plus
// [7] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
// [6] (word~) main::$0 ← callfinalize plus -- _stackpullbyte_2
pla
pla
// [7] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
// [6] (word~) main::$0 ← callfinalize plus -- vwuz1=_stackpullword_
pla
sta.z __0
pla
sta.z __0+1
// SCREEN[0] = plus('0', 7)
// [8] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
// [7] *((const word*) SCREEN) ← (word~) main::$0 -- _deref_pwuc1=vwuz1
lda.z __0
sta SCREEN
lda.z __0+1
sta SCREEN+1
// main::@return
// }
// [9] return
// [8] return
rts
}
// plus
@ -513,20 +510,20 @@ plus: {
.label a = 2
.label b = 4
.label return = 2
// [10] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
// [9] (word) plus::a#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_A) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_A,x
sta.z a
lda STACK_BASE+OFFSET_STACK_A+1,x
sta.z a+1
// [11] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
// [10] (word) plus::b#0 ← stackidx(word,(const byte) plus::OFFSET_STACK_B) -- vwuz1=_stackidxword_vbuc1
tsx
lda STACK_BASE+OFFSET_STACK_B,x
sta.z b
lda STACK_BASE+OFFSET_STACK_B+1,x
sta.z b+1
// return a+b;
// [12] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
// [11] (word) plus::return#0 ← (word) plus::a#0 + (word) plus::b#0 -- vwuz1=vwuz1_plus_vwuz2
lda.z return
clc
adc.z b
@ -536,8 +533,8 @@ plus: {
sta.z return+1
// plus::@return
// }
// [13] return (word) plus::return#0
// [13] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
// [12] return (word) plus::return#0
// [12] return (word) plus::return#0 -- _stackidxword_vbuc1=vwuz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x

3
src/test/ref/procedure-callingconvention-stack-4.asm
View File

@ -12,12 +12,13 @@ main: {
tya
tax
inx
// w = plus('0', v)
// plus('0', v)
lda #'0'
pha
txa
pha
jsr plus
// w = plus('0', v)
pla
pla
// w+a

37
src/test/ref/procedure-callingconvention-stack-4.log
View File

@ -1,6 +1,9 @@
Culled Empty Block (label) main::@2
Culled Empty Block (label) @1
Culled Empty Block (label) plus::@1
Calling convention STACK_CALL adding prepare/execute/finalize for (byte~) main::$1 ← call plus (byte) '0' (byte) main::v
Calling convention STACK_CALL replacing param((byte) plus::a) with stackidx(byte,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((byte) plus::b) with stackidx(byte,(const byte) plus::OFFSET_STACK_B)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -17,7 +20,9 @@ main::@1: scope:[main] from main main::@1
(byte) main::a#2 ← phi( main/(byte) main::a#0 main::@1/(byte) main::a#1 )
(number~) main::$0 ← (byte) main::a#2 + (number) 1
(byte) main::v#0 ← (number~) main::$0
(byte~) main::$1 ← call plus (byte) '0' (byte) main::v#0
callprepare plus (byte) '0' (byte) main::v#0
callexecute plus
(byte~) main::$1 ← callfinalize plus
(byte) main::w#0 ← (byte~) main::$1
(byte~) main::$2 ← (byte) main::w#0 + (byte) main::a#2
*((const byte*) SCREEN + (byte) i#4) ← (byte~) main::$2
@ -34,8 +39,8 @@ main::@return: scope:[main] from main::@1
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
plus: scope:[plus] from
(byte) i#6 ← phi( )
(byte) plus::a#0 ← param((byte) plus::a)
(byte) plus::b#0 ← param((byte) plus::b)
(byte) plus::a#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_A)
(byte) plus::b#0 ← stackidx(byte,(const byte) plus::OFFSET_STACK_B)
(byte) i#2 ← ++ (byte) i#6
(byte~) plus::$0 ← (byte) plus::a#0 + (byte) plus::b#0
(byte) plus::return#0 ← (byte~) plus::$0
@ -60,6 +65,7 @@ SYMBOL TABLE SSA
(label) @begin
(label) @end
(const byte*) SCREEN = (byte*)(number) $400
(const word) STACK_BASE = (word) $103
(byte) i
(byte) i#0
(byte) i#1
@ -89,6 +95,9 @@ SYMBOL TABLE SSA
__stackcall (byte()) plus((byte) plus::a , (byte) plus::b)
(byte~) plus::$0
(label) plus::@return
(const byte) plus::OFFSET_STACK_A = (byte) 1
(const byte) plus::OFFSET_STACK_B = (byte) 0
(const byte) plus::OFFSET_STACK_RETURN = (byte) 1
(byte) plus::a
(byte) plus::a#0
(byte) plus::b
@ -117,16 +126,17 @@ Identical Phi Values (byte) i#8 (byte) i#0
Identical Phi Values (byte) i#1 (byte) i#8
Identical Phi Values (byte) i#3 (byte) i#1
Successful SSA optimization Pass2IdenticalPhiElimination
Simple Condition (bool~) main::$3 [10] if((byte) main::a#1!=rangelast(0,1)) goto main::@1
Simple Condition (bool~) main::$3 [12] if((byte) main::a#1!=rangelast(0,1)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant (const byte) i#0 = 0
Constant (const byte) main::a#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [8] main::a#1 ← ++ main::a#2 to ++
Resolved ranged comparison value [10] if(main::a#1!=rangelast(0,1)) goto main::@1 to (number) 2
Simplifying expression containing zero SCREEN in [7] *((const byte*) SCREEN + (const byte) i#0) ← (byte~) main::$2
Resolved ranged next value [10] main::a#1 ← ++ main::a#2 to ++
Resolved ranged comparison value [12] if(main::a#1!=rangelast(0,1)) goto main::@1 to (number) 2
Simplifying expression containing zero SCREEN in [9] *((const byte*) SCREEN + (const byte) i#0) ← (byte~) main::$2
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (byte) i#2 and assignment [11] (byte) i#2 ← ++ (byte) i#6
Eliminating unused variable (byte) i#2 and assignment [13] (byte) i#2 ← ++ (byte) i#6
Eliminating unused constant (const byte) plus::OFFSET_STACK_RETURN
Eliminating unused constant (const byte) i#0
Successful SSA optimization PassNEliminateUnusedVars
Eliminating unused variable - keeping the phi block (byte) i#6
@ -148,10 +158,10 @@ Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:2
Calls in [main] to plus:8
Calls in [main] to plus:9
Created 1 initial phi equivalence classes
Coalesced [14] main::a#3 ← main::a#1
Coalesced [16] main::a#3 ← main::a#1
Coalesced down to 1 phi equivalence classes
Culled Empty Block (label) @3
Culled Empty Block (label) main::@3
@ -160,9 +170,6 @@ Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Calling convention STACK_CALL adding prepare/execute/finalize for [7] (byte) main::w#0 ← call plus (byte) '0' (byte) main::v#0
Calling convention STACK_CALL replacing param((byte) plus::a) with stackidx(byte,(const byte) plus::OFFSET_STACK_A)
Calling convention STACK_CALL replacing param((byte) plus::b) with stackidx(byte,(const byte) plus::OFFSET_STACK_B)
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
@ -336,7 +343,6 @@ main: {
plus: {
.const OFFSET_STACK_A = 1
.const OFFSET_STACK_B = 0
.const OFFSET_STACK_RETURN = 1
.label a = 6
.label b = 7
.label return = 8
@ -606,7 +612,7 @@ main: {
tya
tax
inx
// w = plus('0', v)
// plus('0', v)
// [7] callprepare plus (byte) '0' (byte) main::v#0 [(byte) plus::a#0] -- _stackpushbyte_=vbuc1
lda #'0'
pha
@ -615,6 +621,7 @@ main: {
pha
// [8] callexecute plus -- jsr
jsr plus
// w = plus('0', v)
// [9] (byte) main::w#0 ← callfinalize plus -- _stackpullbyte_1
pla
// [9] (byte) main::w#0 ← callfinalize plus -- vbuaa=_stackpullbyte_

25
src/test/ref/procedure-callingconvention-stack-5.cfg
View File

@ -10,25 +10,24 @@
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare next
[6] callexecute next
[7] (signed word~) main::$0 ← callfinalize next
[8] *((const signed word*) SCREEN) ← (signed word~) main::$0
[9] callprepare next
[10] callexecute next
[11] (signed word~) main::$1 ← callfinalize next
[12] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1
[4] callprepare next
[5] callexecute next
[6] (signed word~) main::$0 ← callfinalize next
[7] *((const signed word*) SCREEN) ← (signed word~) main::$0
[8] callprepare next
[9] callexecute next
[10] (signed word~) main::$1 ← callfinalize next
[11] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1
to:main::@return
main::@return: scope:[main] from main
[13] return
[12] return
to:@return
__stackcall (signed word()) next()
next: scope:[next] from
[14] (signed word) current#5 ← phi( )
[15] (signed word) next::return#0 ← (signed word) current#5
[13] (signed word) current#5 ← phi( )
[14] (signed word) next::return#0 ← (signed word) current#5
to:next::@return
next::@return: scope:[next] from next
[16] return (signed word) next::return#0
[15] return (signed word) next::return#0
to:@return

143
src/test/ref/procedure-callingconvention-stack-5.log
View File

@ -1,6 +1,8 @@
Fixing pointer array-indexing *((const signed word*) SCREEN + (number) 0)
Fixing pointer array-indexing *((const signed word*) SCREEN + (number) 1)
Culled Empty Block (label) next::@1
Calling convention STACK_CALL adding prepare/execute/finalize for (signed word~) main::$0 ← call next
Calling convention STACK_CALL adding prepare/execute/finalize for (signed word~) main::$1 ← call next
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -9,10 +11,14 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @2
(signed word) current#7 ← phi( @2/(signed word) current#8 )
(signed word~) main::$0 ← call next
callprepare next
callexecute next
(signed word~) main::$0 ← callfinalize next
(number~) main::$2 ← (number) 0 * (const byte) SIZEOF_SIGNED_WORD
*((const signed word*) SCREEN + (number~) main::$2) ← (signed word~) main::$0
(signed word~) main::$1 ← call next
callprepare next
callexecute next
(signed word~) main::$1 ← callfinalize next
(number~) main::$3 ← (number) 1 * (const byte) SIZEOF_SIGNED_WORD
*((const signed word*) SCREEN + (number~) main::$3) ← (signed word~) main::$1
to:main::@return
@ -53,6 +59,7 @@ SYMBOL TABLE SSA
(label) @end
(const signed word*) SCREEN = (signed word*)(number) $400
(const byte) SIZEOF_SIGNED_WORD = (byte) 2
(const word) STACK_BASE = (word) $103
(signed word) current
(signed word) current#0
(signed word) current#1
@ -71,6 +78,7 @@ SYMBOL TABLE SSA
(label) main::@return
__stackcall (signed word()) next()
(label) next::@return
(const byte) next::OFFSET_STACK_RETURN = (byte) 0
(signed word) next::return
(signed word) next::return#0
(signed word) next::return#1
@ -97,8 +105,8 @@ Successful SSA optimization Pass2AliasElimination
Identical Phi Values (signed word) current#0 (signed word) current#1
Identical Phi Values (signed word) current#3 (signed word) current#0
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [2] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [5] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [9] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_SIGNED_WORD
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$2 = 0*SIZEOF_SIGNED_WORD
Constant (const byte) main::$3 = 1*SIZEOF_SIGNED_WORD
@ -106,10 +114,11 @@ Constant (const signed word) current#1 = $30
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_SIGNED_WORD in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero SCREEN in [3] *((const signed word*) SCREEN + (const byte) main::$2) ← (signed word~) main::$0
Simplifying expression containing zero SCREEN in [5] *((const signed word*) SCREEN + (const byte) main::$2) ← (signed word~) main::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (signed word) current#2 and assignment [7] (signed word) current#2 ← ++ (signed word) current#5
Eliminating unused variable (signed word) current#2 and assignment [11] (signed word) current#2 ← ++ (signed word) current#5
Eliminating unused constant (const byte) main::$2
Eliminating unused constant (const byte) next::OFFSET_STACK_RETURN
Eliminating unused constant (const signed word) current#1
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$3 = (byte) 1*(const byte) SIZEOF_SIGNED_WORD
@ -121,10 +130,9 @@ Adding NOP phi() at start of @1
Adding NOP phi() at start of @2
Adding NOP phi() at start of @3
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:3
Calls in [main] to next:7 next:9
Calls in [main] to next:7 next:11
Created 1 initial phi equivalence classes
Coalesced down to 1 phi equivalence classes
@ -134,9 +142,6 @@ Renumbering block @2 to @1
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
Calling convention STACK_CALL adding prepare/execute/finalize for [5] (signed word~) main::$0 ← call next
Calling convention STACK_CALL adding prepare/execute/finalize for [7] (signed word~) main::$1 ← call next
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
@ -151,27 +156,26 @@ FINAL CONTROL FLOW GRAPH
(void()) main()
main: scope:[main] from @1
[4] phi()
[5] callprepare next
[6] callexecute next
[7] (signed word~) main::$0 ← callfinalize next
[8] *((const signed word*) SCREEN) ← (signed word~) main::$0
[9] callprepare next
[10] callexecute next
[11] (signed word~) main::$1 ← callfinalize next
[12] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1
[4] callprepare next
[5] callexecute next
[6] (signed word~) main::$0 ← callfinalize next
[7] *((const signed word*) SCREEN) ← (signed word~) main::$0
[8] callprepare next
[9] callexecute next
[10] (signed word~) main::$1 ← callfinalize next
[11] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1
to:main::@return
main::@return: scope:[main] from main
[13] return
[12] return
to:@return
__stackcall (signed word()) next()
next: scope:[next] from
[14] (signed word) current#5 ← phi( )
[15] (signed word) next::return#0 ← (signed word) current#5
[13] (signed word) current#5 ← phi( )
[14] (signed word) next::return#0 ← (signed word) current#5
to:next::@return
next::@return: scope:[next] from next
[16] return (signed word) next::return#0
[15] return (signed word) next::return#0
to:@return
@ -222,8 +226,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -234,32 +236,32 @@ __bend:
main: {
.label __0 = 4
.label __1 = 6
// [5] callprepare next -- _stackpushbyte_2
// [4] callprepare next -- _stackpushbyte_2
pha
pha
// [6] callexecute next -- jsr
// [5] callexecute next -- jsr
jsr next
// [7] (signed word~) main::$0 ← callfinalize next -- vwsz1=_stackpullsword_
// [6] (signed word~) main::$0 ← callfinalize next -- vwsz1=_stackpullsword_
pla
sta.z __0
pla
sta.z __0+1
// [8] *((const signed word*) SCREEN) ← (signed word~) main::$0 -- _deref_pwsc1=vwsz1
// [7] *((const signed word*) SCREEN) ← (signed word~) main::$0 -- _deref_pwsc1=vwsz1
lda.z __0
sta SCREEN
lda.z __0+1
sta SCREEN+1
// [9] callprepare next -- _stackpushbyte_2
// [8] callprepare next -- _stackpushbyte_2
pha
pha
// [10] callexecute next -- jsr
// [9] callexecute next -- jsr
jsr next
// [11] (signed word~) main::$1 ← callfinalize next -- vwsz1=_stackpullsword_
// [10] (signed word~) main::$1 ← callfinalize next -- vwsz1=_stackpullsword_
pla
sta.z __1
pla
sta.z __1+1
// [12] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 -- _deref_pwsc1=vwsz1
// [11] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 -- _deref_pwsc1=vwsz1
lda.z __1
sta SCREEN+1*SIZEOF_SIGNED_WORD
lda.z __1+1
@ -267,14 +269,13 @@ main: {
jmp __breturn
// main::@return
__breturn:
// [13] return
// [12] return
rts
}
// next
next: {
.const OFFSET_STACK_RETURN = 0
.label return = 8
// [15] (signed word) next::return#0 ← (signed word) current#5 -- vwsz1=vwsz2
// [14] (signed word) next::return#0 ← (signed word) current#5 -- vwsz1=vwsz2
lda.z current
sta.z return
lda.z current+1
@ -282,8 +283,8 @@ next: {
jmp __breturn
// next::@return
__breturn:
// [16] return (signed word) next::return#0
// [16] return (signed word) next::return#0 -- _stackidxsword_vbuc1=vwsz1
// [15] return (signed word) next::return#0
// [15] return (signed word) next::return#0 -- _stackidxsword_vbuc1=vwsz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -294,12 +295,12 @@ next: {
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [7] (signed word~) main::$0 ← callfinalize next [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [8] *((const signed word*) SCREEN) ← (signed word~) main::$0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [11] (signed word~) main::$1 ← callfinalize next [ main::$1 ] ( main:2 [ main::$1 ] ) always clobbers reg byte a
Statement [12] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [15] (signed word) next::return#0 ← (signed word) current#5 [ next::return#0 ] ( main:2::next:6 [ next::return#0 ] main:2::next:10 [ next::return#0 ] ) always clobbers reg byte a
Statement [16] return (signed word) next::return#0 [ ] ( main:2::next:6 [ ] main:2::next:10 [ ] ) always clobbers reg byte a reg byte x
Statement [6] (signed word~) main::$0 ← callfinalize next [ main::$0 ] ( main:2 [ main::$0 ] ) always clobbers reg byte a
Statement [7] *((const signed word*) SCREEN) ← (signed word~) main::$0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [10] (signed word~) main::$1 ← callfinalize next [ main::$1 ] ( main:2 [ main::$1 ] ) always clobbers reg byte a
Statement [11] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [14] (signed word) next::return#0 ← (signed word) current#5 [ next::return#0 ] ( main:2::next:5 [ next::return#0 ] main:2::next:9 [ next::return#0 ] ) always clobbers reg byte a
Statement [15] return (signed word) next::return#0 [ ] ( main:2::next:5 [ ] main:2::next:9 [ ] ) always clobbers reg byte a reg byte x
Potential registers zp[2]:2 [ current#5 ] : zp[2]:2 ,
Potential registers zp[2]:4 [ main::$0 ] : zp[2]:4 ,
Potential registers zp[2]:6 [ main::$1 ] : zp[2]:6 ,
@ -339,8 +340,6 @@ __b1_from___bbegin:
// @1
__b1:
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
main_from___b1:
jsr main
// [3] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
@ -351,32 +350,32 @@ __bend:
main: {
.label __0 = 2
.label __1 = 4
// [5] callprepare next -- _stackpushbyte_2
// [4] callprepare next -- _stackpushbyte_2
pha
pha
// [6] callexecute next -- jsr
// [5] callexecute next -- jsr
jsr next
// [7] (signed word~) main::$0 ← callfinalize next -- vwsz1=_stackpullsword_
// [6] (signed word~) main::$0 ← callfinalize next -- vwsz1=_stackpullsword_
pla
sta.z __0
pla
sta.z __0+1
// [8] *((const signed word*) SCREEN) ← (signed word~) main::$0 -- _deref_pwsc1=vwsz1
// [7] *((const signed word*) SCREEN) ← (signed word~) main::$0 -- _deref_pwsc1=vwsz1
lda.z __0
sta SCREEN
lda.z __0+1
sta SCREEN+1
// [9] callprepare next -- _stackpushbyte_2
// [8] callprepare next -- _stackpushbyte_2
pha
pha
// [10] callexecute next -- jsr
// [9] callexecute next -- jsr
jsr next
// [11] (signed word~) main::$1 ← callfinalize next -- vwsz1=_stackpullsword_
// [10] (signed word~) main::$1 ← callfinalize next -- vwsz1=_stackpullsword_
pla
sta.z __1
pla
sta.z __1+1
// [12] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 -- _deref_pwsc1=vwsz1
// [11] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 -- _deref_pwsc1=vwsz1
lda.z __1
sta SCREEN+1*SIZEOF_SIGNED_WORD
lda.z __1+1
@ -384,19 +383,19 @@ main: {
jmp __breturn
// main::@return
__breturn:
// [13] return
// [12] return
rts
}
// next
next: {
.const OFFSET_STACK_RETURN = 0
.label return = 2
// [15] (signed word) next::return#0 ← (signed word) current#5
// [14] (signed word) next::return#0 ← (signed word) current#5
jmp __breturn
// next::@return
__breturn:
// [16] return (signed word) next::return#0
// [16] return (signed word) next::return#0 -- _stackidxsword_vbuc1=vwsz1
// [15] return (signed word) next::return#0
// [15] return (signed word) next::return#0 -- _stackidxsword_vbuc1=vwsz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x
@ -414,7 +413,6 @@ Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction main_from___b1:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
@ -469,7 +467,6 @@ Score: 110
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] call main
// [4] phi from @1 to main [phi:@1->main]
// [3] phi from @1 to @end [phi:@1->@end]
// @end
// main
@ -477,42 +474,42 @@ main: {
.label __0 = 2
.label __1 = 4
// next()
// [5] callprepare next -- _stackpushbyte_2
// [4] callprepare next -- _stackpushbyte_2
pha
pha
// [6] callexecute next -- jsr
// [5] callexecute next -- jsr
jsr next
// [7] (signed word~) main::$0 ← callfinalize next -- vwsz1=_stackpullsword_
// [6] (signed word~) main::$0 ← callfinalize next -- vwsz1=_stackpullsword_
pla
sta.z __0
pla
sta.z __0+1
// SCREEN[0] = next()
// [8] *((const signed word*) SCREEN) ← (signed word~) main::$0 -- _deref_pwsc1=vwsz1
// [7] *((const signed word*) SCREEN) ← (signed word~) main::$0 -- _deref_pwsc1=vwsz1
lda.z __0
sta SCREEN
lda.z __0+1
sta SCREEN+1
// next()
// [9] callprepare next -- _stackpushbyte_2
// [8] callprepare next -- _stackpushbyte_2
pha
pha
// [10] callexecute next -- jsr
// [9] callexecute next -- jsr
jsr next
// [11] (signed word~) main::$1 ← callfinalize next -- vwsz1=_stackpullsword_
// [10] (signed word~) main::$1 ← callfinalize next -- vwsz1=_stackpullsword_
pla
sta.z __1
pla
sta.z __1+1
// SCREEN[1] = next()
// [12] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 -- _deref_pwsc1=vwsz1
// [11] *((const signed word*) SCREEN+(byte) 1*(const byte) SIZEOF_SIGNED_WORD) ← (signed word~) main::$1 -- _deref_pwsc1=vwsz1
lda.z __1
sta SCREEN+1*SIZEOF_SIGNED_WORD
lda.z __1+1
sta SCREEN+1*SIZEOF_SIGNED_WORD+1
// main::@return
// }
// [13] return
// [12] return
rts
}
// next
@ -520,11 +517,11 @@ next: {
.const OFFSET_STACK_RETURN = 0
.label return = 2
// return current++;
// [15] (signed word) next::return#0 ← (signed word) current#5
// [14] (signed word) next::return#0 ← (signed word) current#5
// next::@return
// }
// [16] return (signed word) next::return#0
// [16] return (signed word) next::return#0 -- _stackidxsword_vbuc1=vwsz1
// [15] return (signed word) next::return#0
// [15] return (signed word) next::return#0 -- _stackidxsword_vbuc1=vwsz1
tsx
lda.z return
sta STACK_BASE+OFFSET_STACK_RETURN,x

33
src/test/ref/procedure-callingconvention-stack-7.cfg
View File

@ -2,38 +2,37 @@
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] callprepare main
[3] callexecute main
[4] callfinalize main
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[5] phi()
[4] phi()
__stackcall (void()) printline()
printline: scope:[printline] from
[6] (byte) printline::i ← (byte) 0
[5] (byte) printline::i ← (byte) 0
to:printline::@1
printline::@1: scope:[printline] from printline printline::@2
[7] if((byte) printline::i<(byte) $28) goto printline::@2
[6] if((byte) printline::i<(byte) $28) goto printline::@2
to:printline::@return
printline::@return: scope:[printline] from printline::@1
[8] return
[7] return
to:@return
printline::@2: scope:[printline] from printline::@1
[9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[10] (byte) printline::i ← ++ (byte) printline::i
[8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[9] (byte) printline::i ← ++ (byte) printline::i
to:printline::@1
__stackcall (void()) main()
main: scope:[main] from
[11] (byte) main::val ← (byte) 0
[12] (byte) main::val ← *((const byte*) SCREEN)
[13] callprepare printline
[14] callexecute printline
[15] callfinalize printline
[16] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val
[10] (byte) main::val ← (byte) 0
[11] (byte) main::val ← *((const byte*) SCREEN)
[12] callprepare printline
[13] callexecute printline
[14] callfinalize printline
[15] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val
to:main::@return
main::@return: scope:[main] from main
[17] return
[16] return
to:@return

175
src/test/ref/procedure-callingconvention-stack-7.log
View File

@ -3,6 +3,8 @@ Culled Empty Block (label) printline::@4
Culled Empty Block (label) printline::@3
Culled Empty Block (label) printline::@5
Culled Empty Block (label) printline::@6
Calling convention STACK_CALL adding prepare/execute/finalize for call printline
Calling convention STACK_CALL adding prepare/execute/finalize for call main
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -12,7 +14,9 @@ __stackcall (void()) main()
main: scope:[main] from
(byte) main::val ← (byte) 0
(byte) main::val ← *((const byte*) SCREEN)
call printline
callprepare printline
callexecute printline
callfinalize printline
*((const byte*) SCREEN + (number) $50) ← (byte) main::val
to:main::@return
main::@return: scope:[main] from main
@ -35,7 +39,9 @@ printline::@return: scope:[printline] from printline::@1
return
to:@return
@2: scope:[] from @begin
call main
callprepare main
callexecute main
callfinalize main
to:@end
@end: scope:[] from @2
@ -64,65 +70,60 @@ Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $50
Finalized unsigned number type (byte) $28
Successful SSA optimization PassNFinalizeNumberTypeConversions
Simple Condition (bool~) printline::$0 [7] if((byte) printline::i<(byte) $28) goto printline::@2
Simple Condition (bool~) printline::$0 [9] if((byte) printline::i<(byte) $28) goto printline::@2
Successful SSA optimization Pass2ConditionalJumpSimplification
Consolidated array index constant in *(SCREEN+$50)
Successful SSA optimization Pass2ConstantAdditionElimination
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @2
Adding NOP phi() at start of @end
CALL GRAPH
Calls in [] to main:2
Calls in [main] to printline:11
Calls in [main] to printline:13
Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Renumbering block @2 to @1
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Calling convention STACK_CALL adding prepare/execute/finalize for [2] call main
Calling convention STACK_CALL adding prepare/execute/finalize for [11] call printline
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] callprepare main
[3] callexecute main
[4] callfinalize main
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[5] phi()
[4] phi()
__stackcall (void()) printline()
printline: scope:[printline] from
[6] (byte) printline::i ← (byte) 0
[5] (byte) printline::i ← (byte) 0
to:printline::@1
printline::@1: scope:[printline] from printline printline::@2
[7] if((byte) printline::i<(byte) $28) goto printline::@2
[6] if((byte) printline::i<(byte) $28) goto printline::@2
to:printline::@return
printline::@return: scope:[printline] from printline::@1
[8] return
[7] return
to:@return
printline::@2: scope:[printline] from printline::@1
[9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[10] (byte) printline::i ← ++ (byte) printline::i
[8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[9] (byte) printline::i ← ++ (byte) printline::i
to:printline::@1
__stackcall (void()) main()
main: scope:[main] from
[11] (byte) main::val ← (byte) 0
[12] (byte) main::val ← *((const byte*) SCREEN)
[13] callprepare printline
[14] callexecute printline
[15] callfinalize printline
[16] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val
[10] (byte) main::val ← (byte) 0
[11] (byte) main::val ← *((const byte*) SCREEN)
[12] callprepare printline
[13] callexecute printline
[14] callfinalize printline
[15] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val
to:main::@return
main::@return: scope:[main] from main
[17] return
[16] return
to:@return
@ -154,16 +155,14 @@ Target platform is c64basic / MOS6502X
.label SCREEN = $400
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
@ -171,62 +170,62 @@ __bend:
// printline
printline: {
.label i = 2
// [6] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
jmp __b1
// printline::@1
__b1:
// [7] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
// [6] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
lda.z i
cmp #$28
bcc __b2
jmp __breturn
// printline::@return
__breturn:
// [8] return
// [7] return
rts
// printline::@2
__b2:
// [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
// [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
lda #'*'
ldy.z i
sta SCREEN,y
// [10] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
// [9] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
inc.z i
jmp __b1
}
// main
main: {
.label val = 3
// [11] (byte) main::val ← (byte) 0 -- vbuz1=vbuc1
// [10] (byte) main::val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [12] (byte) main::val ← *((const byte*) SCREEN) -- vbuz1=_deref_pbuc1
// [11] (byte) main::val ← *((const byte*) SCREEN) -- vbuz1=_deref_pbuc1
lda SCREEN
sta.z val
// [13] callprepare printline
// [14] callexecute printline -- jsr
// [12] callprepare printline
// [13] callexecute printline -- jsr
jsr printline
// [15] callfinalize printline
// [16] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val -- _deref_pbuc1=vbuz1
// [14] callfinalize printline
// [15] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN+$50
jmp __breturn
// main::@return
__breturn:
// [17] return
// [16] return
rts
}
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [6] (byte) printline::i ← (byte) 0 [ printline::i ] ( main:3::printline:14 [ main::val printline::i ] ) always clobbers reg byte a
Statement [7] if((byte) printline::i<(byte) $28) goto printline::@2 [ printline::i ] ( main:3::printline:14 [ main::val printline::i ] ) always clobbers reg byte a
Statement [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' [ printline::i ] ( main:3::printline:14 [ main::val printline::i ] ) always clobbers reg byte a reg byte y
Statement [11] (byte) main::val ← (byte) 0 [ ] ( main:3 [ ] ) always clobbers reg byte a
Statement [12] (byte) main::val ← *((const byte*) SCREEN) [ main::val ] ( main:3 [ main::val ] ) always clobbers reg byte a
Statement [16] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val [ ] ( main:3 [ ] ) always clobbers reg byte a
Statement [5] (byte) printline::i ← (byte) 0 [ printline::i ] ( main:2::printline:13 [ main::val printline::i ] ) always clobbers reg byte a
Statement [6] if((byte) printline::i<(byte) $28) goto printline::@2 [ printline::i ] ( main:2::printline:13 [ main::val printline::i ] ) always clobbers reg byte a
Statement [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' [ printline::i ] ( main:2::printline:13 [ main::val printline::i ] ) always clobbers reg byte a reg byte y
Statement [10] (byte) main::val ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [11] (byte) main::val ← *((const byte*) SCREEN) [ main::val ] ( main:2 [ main::val ] ) always clobbers reg byte a
Statement [15] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val [ ] ( main:2 [ ] ) always clobbers reg byte a
Potential registers zp[1]:2 [ printline::i ] : zp[1]:2 ,
Potential registers zp[1]:3 [ main::val ] : zp[1]:3 ,
@ -235,13 +234,13 @@ Uplift Scope [printline] 11.5: zp[1]:2 [ printline::i ]
Uplift Scope [main] 1.5: zp[1]:3 [ main::val ]
Uplift Scope []
Uplifting [printline] best 345 combination zp[1]:2 [ printline::i ]
Uplifting [main] best 345 combination zp[1]:3 [ main::val ]
Uplifting [] best 345 combination
Uplifting [printline] best 372 combination zp[1]:2 [ printline::i ]
Uplifting [main] best 372 combination zp[1]:3 [ main::val ]
Uplifting [] best 372 combination
Attempting to uplift remaining variables inzp[1]:2 [ printline::i ]
Uplifting [printline] best 345 combination zp[1]:2 [ printline::i ]
Uplifting [printline] best 372 combination zp[1]:2 [ printline::i ]
Attempting to uplift remaining variables inzp[1]:3 [ main::val ]
Uplifting [main] best 345 combination zp[1]:3 [ main::val ]
Uplifting [main] best 372 combination zp[1]:3 [ main::val ]
ASSEMBLER BEFORE OPTIMIZATION
// File Comments
@ -255,16 +254,14 @@ ASSEMBLER BEFORE OPTIMIZATION
.label SCREEN = $400
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
@ -272,51 +269,51 @@ __bend:
// printline
printline: {
.label i = 2
// [6] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
jmp __b1
// printline::@1
__b1:
// [7] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
// [6] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
lda.z i
cmp #$28
bcc __b2
jmp __breturn
// printline::@return
__breturn:
// [8] return
// [7] return
rts
// printline::@2
__b2:
// [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
// [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
lda #'*'
ldy.z i
sta SCREEN,y
// [10] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
// [9] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
inc.z i
jmp __b1
}
// main
main: {
.label val = 3
// [11] (byte) main::val ← (byte) 0 -- vbuz1=vbuc1
// [10] (byte) main::val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [12] (byte) main::val ← *((const byte*) SCREEN) -- vbuz1=_deref_pbuc1
// [11] (byte) main::val ← *((const byte*) SCREEN) -- vbuz1=_deref_pbuc1
lda SCREEN
sta.z val
// [13] callprepare printline
// [14] callexecute printline -- jsr
// [12] callprepare printline
// [13] callexecute printline -- jsr
jsr printline
// [15] callfinalize printline
// [16] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val -- _deref_pbuc1=vbuz1
// [14] callfinalize printline
// [15] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN+$50
jmp __breturn
// main::@return
__breturn:
// [17] return
// [16] return
rts
}
// File Data
@ -328,7 +325,6 @@ Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __b1:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
@ -371,42 +367,41 @@ Score: 309
.label SCREEN = $400
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
rts
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
// @end
// printline
printline: {
.label i = 2
// i=0
// [6] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
// printline::@1
__b1:
// for(char i=0; i<40; i++)
// [7] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
// [6] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
lda.z i
cmp #$28
bcc __b2
// printline::@return
// }
// [8] return
// [7] return
rts
// printline::@2
__b2:
// SCREEN[i] = '*'
// [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
// [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
lda #'*'
ldy.z i
sta SCREEN,y
// for(char i=0; i<40; i++)
// [10] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
// [9] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
inc.z i
jmp __b1
}
@ -414,25 +409,25 @@ printline: {
main: {
.label val = 3
// val
// [11] (byte) main::val ← (byte) 0 -- vbuz1=vbuc1
// [10] (byte) main::val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// val = *SCREEN
// [12] (byte) main::val ← *((const byte*) SCREEN) -- vbuz1=_deref_pbuc1
// [11] (byte) main::val ← *((const byte*) SCREEN) -- vbuz1=_deref_pbuc1
lda SCREEN
sta.z val
// printline()
// [13] callprepare printline
// [14] callexecute printline -- jsr
// [12] callprepare printline
// [13] callexecute printline -- jsr
jsr printline
// [15] callfinalize printline
// [14] callfinalize printline
// SCREEN[80] = val
// [16] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val -- _deref_pbuc1=vbuz1
// [15] *((const byte*) SCREEN+(byte) $50) ← (byte) main::val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN+$50
// main::@return
// }
// [17] return
// [16] return
rts
}
// File Data

31
src/test/ref/procedure-callingconvention-stack-8.cfg
View File

@ -2,37 +2,36 @@
[0] (byte) val ← (byte) 0
to:@1
@1: scope:[] from @begin
[1] phi()
[2] callprepare main
[3] callexecute main
[4] callfinalize main
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[5] phi()
[4] phi()
__stackcall (void()) printline()
printline: scope:[printline] from
[6] (byte) printline::i ← (byte) 0
[5] (byte) printline::i ← (byte) 0
to:printline::@1
printline::@1: scope:[printline] from printline printline::@2
[7] if((byte) printline::i<(byte) $28) goto printline::@2
[6] if((byte) printline::i<(byte) $28) goto printline::@2
to:printline::@return
printline::@return: scope:[printline] from printline::@1
[8] return
[7] return
to:@return
printline::@2: scope:[printline] from printline::@1
[9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[10] (byte) printline::i ← ++ (byte) printline::i
[8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[9] (byte) printline::i ← ++ (byte) printline::i
to:printline::@1
__stackcall (void()) main()
main: scope:[main] from
[11] (byte) val ← (byte) '-'
[12] callprepare printline
[13] callexecute printline
[14] callfinalize printline
[15] *((const byte*) SCREEN+(byte) $50) ← (byte) val
[10] (byte) val ← (byte) '-'
[11] callprepare printline
[12] callexecute printline
[13] callfinalize printline
[14] *((const byte*) SCREEN+(byte) $50) ← (byte) val
to:main::@return
main::@return: scope:[main] from main
[16] return
[15] return
to:@return

155
src/test/ref/procedure-callingconvention-stack-8.log
View File

@ -3,6 +3,8 @@ Culled Empty Block (label) printline::@4
Culled Empty Block (label) printline::@3
Culled Empty Block (label) printline::@5
Culled Empty Block (label) printline::@6
Calling convention STACK_CALL adding prepare/execute/finalize for call printline
Calling convention STACK_CALL adding prepare/execute/finalize for call main
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -12,7 +14,9 @@ CONTROL FLOW GRAPH SSA
__stackcall (void()) main()
main: scope:[main] from
(byte) val ← (byte) '-'
call printline
callprepare printline
callexecute printline
callfinalize printline
*((const byte*) SCREEN + (number) $50) ← (byte) val
to:main::@return
main::@return: scope:[main] from main
@ -35,7 +39,9 @@ printline::@return: scope:[printline] from printline::@1
return
to:@return
@2: scope:[] from @begin
call main
callprepare main
callexecute main
callfinalize main
to:@end
@end: scope:[] from @2
@ -64,62 +70,57 @@ Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $50
Finalized unsigned number type (byte) $28
Successful SSA optimization PassNFinalizeNumberTypeConversions
Simple Condition (bool~) printline::$0 [7] if((byte) printline::i<(byte) $28) goto printline::@2
Simple Condition (bool~) printline::$0 [9] if((byte) printline::i<(byte) $28) goto printline::@2
Successful SSA optimization Pass2ConditionalJumpSimplification
Consolidated array index constant in *(SCREEN+$50)
Successful SSA optimization Pass2ConstantAdditionElimination
Adding NOP phi() at start of @2
Adding NOP phi() at start of @end
CALL GRAPH
Calls in [] to main:2
Calls in [main] to printline:10
Calls in [main] to printline:12
Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Renumbering block @2 to @1
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Calling convention STACK_CALL adding prepare/execute/finalize for [2] call main
Calling convention STACK_CALL adding prepare/execute/finalize for [10] call printline
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
[0] (byte) val ← (byte) 0
to:@1
@1: scope:[] from @begin
[1] phi()
[2] callprepare main
[3] callexecute main
[4] callfinalize main
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[5] phi()
[4] phi()
__stackcall (void()) printline()
printline: scope:[printline] from
[6] (byte) printline::i ← (byte) 0
[5] (byte) printline::i ← (byte) 0
to:printline::@1
printline::@1: scope:[printline] from printline printline::@2
[7] if((byte) printline::i<(byte) $28) goto printline::@2
[6] if((byte) printline::i<(byte) $28) goto printline::@2
to:printline::@return
printline::@return: scope:[printline] from printline::@1
[8] return
[7] return
to:@return
printline::@2: scope:[printline] from printline::@1
[9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[10] (byte) printline::i ← ++ (byte) printline::i
[8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*'
[9] (byte) printline::i ← ++ (byte) printline::i
to:printline::@1
__stackcall (void()) main()
main: scope:[main] from
[11] (byte) val ← (byte) '-'
[12] callprepare printline
[13] callexecute printline
[14] callfinalize printline
[15] *((const byte*) SCREEN+(byte) $50) ← (byte) val
[10] (byte) val ← (byte) '-'
[11] callprepare printline
[12] callexecute printline
[13] callfinalize printline
[14] *((const byte*) SCREEN+(byte) $50) ← (byte) val
to:main::@return
main::@return: scope:[main] from main
[16] return
[15] return
to:@return
@ -155,16 +156,14 @@ __bbegin:
// [0] (byte) val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
@ -172,58 +171,58 @@ __bend:
// printline
printline: {
.label i = 3
// [6] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
jmp __b1
// printline::@1
__b1:
// [7] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
// [6] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
lda.z i
cmp #$28
bcc __b2
jmp __breturn
// printline::@return
__breturn:
// [8] return
// [7] return
rts
// printline::@2
__b2:
// [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
// [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
lda #'*'
ldy.z i
sta SCREEN,y
// [10] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
// [9] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
inc.z i
jmp __b1
}
// main
main: {
// [11] (byte) val ← (byte) '-' -- vbuz1=vbuc1
// [10] (byte) val ← (byte) '-' -- vbuz1=vbuc1
lda #'-'
sta.z val
// [12] callprepare printline
// [13] callexecute printline -- jsr
// [11] callprepare printline
// [12] callexecute printline -- jsr
jsr printline
// [14] callfinalize printline
// [15] *((const byte*) SCREEN+(byte) $50) ← (byte) val -- _deref_pbuc1=vbuz1
// [13] callfinalize printline
// [14] *((const byte*) SCREEN+(byte) $50) ← (byte) val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN+$50
jmp __breturn
// main::@return
__breturn:
// [16] return
// [15] return
rts
}
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [0] (byte) val ← (byte) 0 [ ] ( [ ] ) always clobbers reg byte a
Statement [6] (byte) printline::i ← (byte) 0 [ printline::i ] ( main:3::printline:13 [ val printline::i ] ) always clobbers reg byte a
Statement [7] if((byte) printline::i<(byte) $28) goto printline::@2 [ printline::i ] ( main:3::printline:13 [ val printline::i ] ) always clobbers reg byte a
Statement [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' [ printline::i ] ( main:3::printline:13 [ val printline::i ] ) always clobbers reg byte a reg byte y
Statement [11] (byte) val ← (byte) '-' [ val ] ( main:3 [ val ] ) always clobbers reg byte a
Statement [15] *((const byte*) SCREEN+(byte) $50) ← (byte) val [ ] ( main:3 [ ] ) always clobbers reg byte a
Statement [5] (byte) printline::i ← (byte) 0 [ printline::i ] ( main:2::printline:12 [ val printline::i ] ) always clobbers reg byte a
Statement [6] if((byte) printline::i<(byte) $28) goto printline::@2 [ printline::i ] ( main:2::printline:12 [ val printline::i ] ) always clobbers reg byte a
Statement [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' [ printline::i ] ( main:2::printline:12 [ val printline::i ] ) always clobbers reg byte a reg byte y
Statement [10] (byte) val ← (byte) '-' [ val ] ( main:2 [ val ] ) always clobbers reg byte a
Statement [14] *((const byte*) SCREEN+(byte) $50) ← (byte) val [ ] ( main:2 [ ] ) always clobbers reg byte a
Potential registers zp[1]:2 [ val ] : zp[1]:2 ,
Potential registers zp[1]:3 [ printline::i ] : zp[1]:3 ,
@ -256,16 +255,14 @@ __bbegin:
// [0] (byte) val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
@ -273,47 +270,47 @@ __bend:
// printline
printline: {
.label i = 3
// [6] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
jmp __b1
// printline::@1
__b1:
// [7] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
// [6] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
lda.z i
cmp #$28
bcc __b2
jmp __breturn
// printline::@return
__breturn:
// [8] return
// [7] return
rts
// printline::@2
__b2:
// [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
// [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
lda #'*'
ldy.z i
sta SCREEN,y
// [10] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
// [9] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
inc.z i
jmp __b1
}
// main
main: {
// [11] (byte) val ← (byte) '-' -- vbuz1=vbuc1
// [10] (byte) val ← (byte) '-' -- vbuz1=vbuc1
lda #'-'
sta.z val
// [12] callprepare printline
// [13] callexecute printline -- jsr
// [11] callprepare printline
// [12] callexecute printline -- jsr
jsr printline
// [14] callfinalize printline
// [15] *((const byte*) SCREEN+(byte) $50) ← (byte) val -- _deref_pbuc1=vbuz1
// [13] callfinalize printline
// [14] *((const byte*) SCREEN+(byte) $50) ← (byte) val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN+$50
jmp __breturn
// main::@return
__breturn:
// [16] return
// [15] return
rts
}
// File Data
@ -325,7 +322,6 @@ Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from___bbegin:
Removing instruction __bend_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __b1:
@ -373,63 +369,62 @@ __bbegin:
// [0] (byte) val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
rts
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
// @end
// printline
printline: {
.label i = 3
// i=0
// [6] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printline::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
// printline::@1
__b1:
// for(char i=0; i<40; i++)
// [7] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
// [6] if((byte) printline::i<(byte) $28) goto printline::@2 -- vbuz1_lt_vbuc1_then_la1
lda.z i
cmp #$28
bcc __b2
// printline::@return
// }
// [8] return
// [7] return
rts
// printline::@2
__b2:
// SCREEN[i] = '*'
// [9] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
// [8] *((const byte*) SCREEN + (byte) printline::i) ← (byte) '*' -- pbuc1_derefidx_vbuz1=vbuc2
lda #'*'
ldy.z i
sta SCREEN,y
// for(char i=0; i<40; i++)
// [10] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
// [9] (byte) printline::i ← ++ (byte) printline::i -- vbuz1=_inc_vbuz1
inc.z i
jmp __b1
}
// main
main: {
// val = '-'
// [11] (byte) val ← (byte) '-' -- vbuz1=vbuc1
// [10] (byte) val ← (byte) '-' -- vbuz1=vbuc1
lda #'-'
sta.z val
// printline()
// [12] callprepare printline
// [13] callexecute printline -- jsr
// [11] callprepare printline
// [12] callexecute printline -- jsr
jsr printline
// [14] callfinalize printline
// [13] callfinalize printline
// SCREEN[80] = val
// [15] *((const byte*) SCREEN+(byte) $50) ← (byte) val -- _deref_pbuc1=vbuz1
// [14] *((const byte*) SCREEN+(byte) $50) ← (byte) val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN+$50
// main::@return
// }
// [16] return
// [15] return
rts
}
// File Data

72
src/test/ref/procedure-callingconvention-stack-9.cfg
View File

@ -2,83 +2,79 @@
[0] (byte) val ← (byte) 0
to:@1
@1: scope:[] from @begin
[1] phi()
[2] callprepare main
[3] callexecute main
[4] callfinalize main
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[5] phi()
[4] phi()
__stackcall (void()) printother()
printother: scope:[printother] from
[6] (byte) printother::i ← (byte) 0
[5] (byte) printother::i ← (byte) 0
to:printother::@1
printother::@1: scope:[printother] from printother printother::@1
[7] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i)
[8] (byte) printother::i ← ++ (byte) printother::i
[9] if((byte) printother::i!=(byte) 6) goto printother::@1
[6] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i)
[7] (byte) printother::i ← ++ (byte) printother::i
[8] if((byte) printother::i!=(byte) 6) goto printother::@1
to:printother::@return
printother::@return: scope:[printother] from printother::@1
[10] return
[9] return
to:@return
__stackcall (void()) incval()
incval: scope:[incval] from
[11] (byte) val ← ++ (byte) val
[10] (byte) val ← ++ (byte) val
to:incval::@return
incval::@return: scope:[incval] from incval
[12] return
[11] return
to:@return
__stackcall (void()) printval()
printval: scope:[printval] from
[13] *((const byte*) SCREEN) ← (byte) val
[12] *((const byte*) SCREEN) ← (byte) val
to:printval::@return
printval::@return: scope:[printval] from printval
[14] return
[13] return
to:@return
__stackcall (void()) ival()
ival: scope:[ival] from
[15] phi()
[16] callprepare incval
[17] callexecute incval
[18] callfinalize incval
[14] callprepare incval
[15] callexecute incval
[16] callfinalize incval
to:ival::@return
ival::@return: scope:[ival] from ival
[19] return
[17] return
to:@return
__stackcall (void()) pval()
pval: scope:[pval] from
[20] phi()
[21] callprepare printval
[22] callexecute printval
[23] callfinalize printval
[18] callprepare printval
[19] callexecute printval
[20] callfinalize printval
to:pval::@return
pval::@return: scope:[pval] from pval
[24] return
[21] return
to:@return
__stackcall (void()) main()
main: scope:[main] from
[25] (byte) main::i ← (byte) 0
[22] (byte) main::i ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@1
[26] phi()
[27] callprepare pval
[28] callexecute pval
[29] callfinalize pval
[30] callprepare printother
[31] callexecute printother
[32] callfinalize printother
[33] callprepare ival
[34] callexecute ival
[35] callfinalize ival
[36] (byte) main::i ← ++ (byte) main::i
[37] if((byte) main::i!=(byte) 6) goto main::@1
[23] callprepare pval
[24] callexecute pval
[25] callfinalize pval
[26] callprepare printother
[27] callexecute printother
[28] callfinalize printother
[29] callprepare ival
[30] callexecute ival
[31] callfinalize ival
[32] (byte) main::i ← ++ (byte) main::i
[33] if((byte) main::i!=(byte) 6) goto main::@1
to:main::@return
main::@return: scope:[main] from main::@1
[38] return
[34] return
to:@return

404
src/test/ref/procedure-callingconvention-stack-9.log
View File

@ -5,6 +5,12 @@ Culled Empty Block (label) @3
Culled Empty Block (label) @4
Culled Empty Block (label) @5
Culled Empty Block (label) printother::@2
Calling convention STACK_CALL adding prepare/execute/finalize for call pval
Calling convention STACK_CALL adding prepare/execute/finalize for call printother
Calling convention STACK_CALL adding prepare/execute/finalize for call ival
Calling convention STACK_CALL adding prepare/execute/finalize for call printval
Calling convention STACK_CALL adding prepare/execute/finalize for call incval
Calling convention STACK_CALL adding prepare/execute/finalize for call main
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -16,9 +22,15 @@ main: scope:[main] from
(byte) main::i ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@1
call pval
call printother
call ival
callprepare pval
callexecute pval
callfinalize pval
callprepare printother
callexecute printother
callfinalize printother
callprepare ival
callexecute ival
callfinalize ival
(byte) main::i ← (byte) main::i + rangenext(0,5)
(bool~) main::$3 ← (byte) main::i != rangelast(0,5)
if((bool~) main::$3) goto main::@1
@ -29,7 +41,9 @@ main::@return: scope:[main] from main::@1
__stackcall (void()) pval()
pval: scope:[pval] from
call printval
callprepare printval
callexecute printval
callfinalize printval
to:pval::@return
pval::@return: scope:[pval] from pval
return
@ -37,7 +51,9 @@ pval::@return: scope:[pval] from pval
__stackcall (void()) ival()
ival: scope:[ival] from
call incval
callprepare incval
callexecute incval
callfinalize incval
to:ival::@return
ival::@return: scope:[ival] from ival
return
@ -73,7 +89,9 @@ printother::@return: scope:[printother] from printother::@1
return
to:@return
@6: scope:[] from @begin
call main
callprepare main
callexecute main
callfinalize main
to:@end
@end: scope:[] from @6
@ -112,14 +130,14 @@ Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) $28
Successful SSA optimization PassNFinalizeNumberTypeConversions
Simple Condition (bool~) main::$3 [7] if((byte) main::i!=rangelast(0,5)) goto main::@1
Simple Condition (bool~) printother::$1 [21] if((byte) printother::i!=rangelast(0,5)) goto printother::@1
Simple Condition (bool~) main::$3 [13] if((byte) main::i!=rangelast(0,5)) goto main::@1
Simple Condition (bool~) printother::$1 [31] if((byte) printother::i!=rangelast(0,5)) goto printother::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Resolved ranged next value [5] main::i ← ++ main::i to ++
Resolved ranged comparison value [7] if(main::i!=rangelast(0,5)) goto main::@1 to (number) 6
Resolved ranged next value [19] printother::i ← ++ printother::i to ++
Resolved ranged comparison value [21] if(printother::i!=rangelast(0,5)) goto printother::@1 to (number) 6
Simplifying expression containing zero SCREEN in [13] *((const byte*) SCREEN + (byte) 0) ← (byte) val
Resolved ranged next value [11] main::i ← ++ main::i to ++
Resolved ranged comparison value [13] if(main::i!=rangelast(0,5)) goto main::@1 to (number) 6
Resolved ranged next value [29] printother::i ← ++ printother::i to ++
Resolved ranged comparison value [31] if(printother::i!=rangelast(0,5)) goto printother::@1 to (number) 6
Simplifying expression containing zero SCREEN in [23] *((const byte*) SCREEN + (byte) 0) ← (byte) val
Successful SSA optimization PassNSimplifyExpressionWithZero
Adding number conversion cast (unumber) 6 in if((byte) main::i!=(number) 6) goto main::@1
Adding number conversion cast (unumber) 6 in if((byte) printother::i!=(number) 6) goto printother::@1
@ -130,116 +148,98 @@ Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 6
Finalized unsigned number type (byte) 6
Successful SSA optimization PassNFinalizeNumberTypeConversions
Adding NOP phi() at start of @6
Adding NOP phi() at start of @end
Adding NOP phi() at start of ival
Adding NOP phi() at start of pval
Adding NOP phi() at start of main::@1
CALL GRAPH
Calls in [] to main:2
Calls in [ival] to incval:14
Calls in [pval] to printval:17
Calls in [main] to pval:21 printother:22 ival:23
Calls in [ival] to incval:15
Calls in [pval] to printval:19
Calls in [main] to pval:24 printother:27 ival:30
Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Renumbering block @6 to @1
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of ival
Adding NOP phi() at start of pval
Adding NOP phi() at start of main::@1
Calling convention STACK_CALL adding prepare/execute/finalize for [2] call main
Calling convention STACK_CALL adding prepare/execute/finalize for [14] call incval
Calling convention STACK_CALL adding prepare/execute/finalize for [17] call printval
Calling convention STACK_CALL adding prepare/execute/finalize for [21] call pval
Calling convention STACK_CALL adding prepare/execute/finalize for [22] call printother
Calling convention STACK_CALL adding prepare/execute/finalize for [23] call ival
FINAL CONTROL FLOW GRAPH
@begin: scope:[] from
[0] (byte) val ← (byte) 0
to:@1
@1: scope:[] from @begin
[1] phi()
[2] callprepare main
[3] callexecute main
[4] callfinalize main
[1] callprepare main
[2] callexecute main
[3] callfinalize main
to:@end
@end: scope:[] from @1
[5] phi()
[4] phi()
__stackcall (void()) printother()
printother: scope:[printother] from
[6] (byte) printother::i ← (byte) 0
[5] (byte) printother::i ← (byte) 0
to:printother::@1
printother::@1: scope:[printother] from printother printother::@1
[7] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i)
[8] (byte) printother::i ← ++ (byte) printother::i
[9] if((byte) printother::i!=(byte) 6) goto printother::@1
[6] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i)
[7] (byte) printother::i ← ++ (byte) printother::i
[8] if((byte) printother::i!=(byte) 6) goto printother::@1
to:printother::@return
printother::@return: scope:[printother] from printother::@1
[10] return
[9] return
to:@return
__stackcall (void()) incval()
incval: scope:[incval] from
[11] (byte) val ← ++ (byte) val
[10] (byte) val ← ++ (byte) val
to:incval::@return
incval::@return: scope:[incval] from incval
[12] return
[11] return
to:@return
__stackcall (void()) printval()
printval: scope:[printval] from
[13] *((const byte*) SCREEN) ← (byte) val
[12] *((const byte*) SCREEN) ← (byte) val
to:printval::@return
printval::@return: scope:[printval] from printval
[14] return
[13] return
to:@return
__stackcall (void()) ival()
ival: scope:[ival] from
[15] phi()
[16] callprepare incval
[17] callexecute incval
[18] callfinalize incval
[14] callprepare incval
[15] callexecute incval
[16] callfinalize incval
to:ival::@return
ival::@return: scope:[ival] from ival
[19] return
[17] return
to:@return
__stackcall (void()) pval()
pval: scope:[pval] from
[20] phi()
[21] callprepare printval
[22] callexecute printval
[23] callfinalize printval
[18] callprepare printval
[19] callexecute printval
[20] callfinalize printval
to:pval::@return
pval::@return: scope:[pval] from pval
[24] return
[21] return
to:@return
__stackcall (void()) main()
main: scope:[main] from
[25] (byte) main::i ← (byte) 0
[22] (byte) main::i ← (byte) 0
to:main::@1
main::@1: scope:[main] from main main::@1
[26] phi()
[27] callprepare pval
[28] callexecute pval
[29] callfinalize pval
[30] callprepare printother
[31] callexecute printother
[32] callfinalize printother
[33] callprepare ival
[34] callexecute ival
[35] callfinalize ival
[36] (byte) main::i ← ++ (byte) main::i
[37] if((byte) main::i!=(byte) 6) goto main::@1
[23] callprepare pval
[24] callexecute pval
[25] callfinalize pval
[26] callprepare printother
[27] callexecute printother
[28] callfinalize printother
[29] callprepare ival
[30] callexecute ival
[31] callfinalize ival
[32] (byte) main::i ← ++ (byte) main::i
[33] if((byte) main::i!=(byte) 6) goto main::@1
to:main::@return
main::@return: scope:[main] from main::@1
[38] return
[34] return
to:@return
null depth in calling loop Loop head: main::@1 tails: main::@1 blocks: main::@1 in scope printother
@ -252,12 +252,12 @@ VARIABLE REGISTER WEIGHTS
__stackcall (void()) incval()
__stackcall (void()) ival()
__stackcall (void()) main()
(byte) main::i loadstore 2.6923076923076925
(byte) main::i loadstore 2.9166666666666665
__stackcall (void()) printother()
(byte) printother::i loadstore 14.25
__stackcall (void()) printval()
__stackcall (void()) pval()
(byte) val loadstore 0.26666666666666666
(byte) val loadstore 0.3076923076923077
Initial phi equivalence classes
Added variable val to live range equivalence class [ val ]
@ -288,16 +288,14 @@ __bbegin:
// [0] (byte) val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
@ -305,144 +303,141 @@ __bend:
// printother
printother: {
.label i = 3
// [6] (byte) printother::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printother::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
jmp __b1
// printother::@1
__b1:
// [7] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) -- pbuc1_derefidx_vbuz1=_inc_pbuc1_derefidx_vbuz1
// [6] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) -- pbuc1_derefidx_vbuz1=_inc_pbuc1_derefidx_vbuz1
ldx.z i
inc SCREEN+$28,x
// [8] (byte) printother::i ← ++ (byte) printother::i -- vbuz1=_inc_vbuz1
// [7] (byte) printother::i ← ++ (byte) printother::i -- vbuz1=_inc_vbuz1
inc.z i
// [9] if((byte) printother::i!=(byte) 6) goto printother::@1 -- vbuz1_neq_vbuc1_then_la1
// [8] if((byte) printother::i!=(byte) 6) goto printother::@1 -- vbuz1_neq_vbuc1_then_la1
lda #6
cmp.z i
bne __b1
jmp __breturn
// printother::@return
__breturn:
// [10] return
// [9] return
rts
}
// incval
incval: {
// [11] (byte) val ← ++ (byte) val -- vbuz1=_inc_vbuz1
// [10] (byte) val ← ++ (byte) val -- vbuz1=_inc_vbuz1
inc.z val
jmp __breturn
// incval::@return
__breturn:
// [12] return
// [11] return
rts
}
// printval
printval: {
// [13] *((const byte*) SCREEN) ← (byte) val -- _deref_pbuc1=vbuz1
// [12] *((const byte*) SCREEN) ← (byte) val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN
jmp __breturn
// printval::@return
__breturn:
// [14] return
// [13] return
rts
}
// ival
ival: {
// [16] callprepare incval
// [17] callexecute incval -- jsr
// [14] callprepare incval
// [15] callexecute incval -- jsr
jsr incval
// [18] callfinalize incval
// [16] callfinalize incval
jmp __breturn
// ival::@return
__breturn:
// [19] return
// [17] return
rts
}
// pval
pval: {
// [21] callprepare printval
// [22] callexecute printval -- jsr
// [18] callprepare printval
// [19] callexecute printval -- jsr
jsr printval
// [23] callfinalize printval
// [20] callfinalize printval
jmp __breturn
// pval::@return
__breturn:
// [24] return
// [21] return
rts
}
// main
main: {
.label i = 4
// [25] (byte) main::i ← (byte) 0 -- vbuz1=vbuc1
// [22] (byte) main::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
// [26] phi from main main::@1 to main::@1 [phi:main/main::@1->main::@1]
__b1_from_main:
__b1_from___b1:
jmp __b1
// main::@1
__b1:
// [27] callprepare pval
// [28] callexecute pval -- jsr
// [23] callprepare pval
// [24] callexecute pval -- jsr
jsr pval
// [29] callfinalize pval
// [30] callprepare printother
// [31] callexecute printother -- jsr
// [25] callfinalize pval
// [26] callprepare printother
// [27] callexecute printother -- jsr
jsr printother
// [32] callfinalize printother
// [33] callprepare ival
// [34] callexecute ival -- jsr
// [28] callfinalize printother
// [29] callprepare ival
// [30] callexecute ival -- jsr
jsr ival
// [35] callfinalize ival
// [36] (byte) main::i ← ++ (byte) main::i -- vbuz1=_inc_vbuz1
// [31] callfinalize ival
// [32] (byte) main::i ← ++ (byte) main::i -- vbuz1=_inc_vbuz1
inc.z i
// [37] if((byte) main::i!=(byte) 6) goto main::@1 -- vbuz1_neq_vbuc1_then_la1
// [33] if((byte) main::i!=(byte) 6) goto main::@1 -- vbuz1_neq_vbuc1_then_la1
lda #6
cmp.z i
bne __b1_from___b1
bne __b1
jmp __breturn
// main::@return
__breturn:
// [38] return
// [34] return
rts
}
// File Data
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [0] (byte) val ← (byte) 0 [ val ] ( [ val ] ) always clobbers reg byte a
Statement [6] (byte) printother::i ← (byte) 0 [ printother::i ] ( main:3::printother:31 [ val main::i printother::i ] ) always clobbers reg byte a
Statement [7] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) [ printother::i ] ( main:3::printother:31 [ val main::i printother::i ] ) always clobbers reg byte x
Statement [9] if((byte) printother::i!=(byte) 6) goto printother::@1 [ printother::i ] ( main:3::printother:31 [ val main::i printother::i ] ) always clobbers reg byte a
Statement [13] *((const byte*) SCREEN) ← (byte) val [ val ] ( main:3::pval:28::printval:22 [ main::i val ] ) always clobbers reg byte a
Statement [25] (byte) main::i ← (byte) 0 [ val main::i ] ( main:3 [ val main::i ] ) always clobbers reg byte a
Statement [37] if((byte) main::i!=(byte) 6) goto main::@1 [ val main::i ] ( main:3 [ val main::i ] ) always clobbers reg byte a
Statement [5] (byte) printother::i ← (byte) 0 [ printother::i ] ( main:2::printother:27 [ val main::i printother::i ] ) always clobbers reg byte a
Statement [6] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) [ printother::i ] ( main:2::printother:27 [ val main::i printother::i ] ) always clobbers reg byte x
Statement [8] if((byte) printother::i!=(byte) 6) goto printother::@1 [ printother::i ] ( main:2::printother:27 [ val main::i printother::i ] ) always clobbers reg byte a
Statement [12] *((const byte*) SCREEN) ← (byte) val [ val ] ( main:2::pval:24::printval:19 [ main::i val ] ) always clobbers reg byte a
Statement [22] (byte) main::i ← (byte) 0 [ val main::i ] ( main:2 [ val main::i ] ) always clobbers reg byte a
Statement [33] if((byte) main::i!=(byte) 6) goto main::@1 [ val main::i ] ( main:2 [ val main::i ] ) always clobbers reg byte a
Potential registers zp[1]:2 [ val ] : zp[1]:2 ,
Potential registers zp[1]:3 [ printother::i ] : zp[1]:3 ,
Potential registers zp[1]:4 [ main::i ] : zp[1]:4 ,
REGISTER UPLIFT SCOPES
Uplift Scope [printother] 14.25: zp[1]:3 [ printother::i ]
Uplift Scope [main] 2.69: zp[1]:4 [ main::i ]
Uplift Scope [] 0.27: zp[1]:2 [ val ]
Uplift Scope [main] 2.92: zp[1]:4 [ main::i ]
Uplift Scope [] 0.31: zp[1]:2 [ val ]
Uplift Scope [pval]
Uplift Scope [ival]
Uplift Scope [printval]
Uplift Scope [incval]
Uplifting [printother] best 722 combination zp[1]:3 [ printother::i ]
Uplifting [main] best 722 combination zp[1]:4 [ main::i ]
Uplifting [] best 722 combination zp[1]:2 [ val ]
Uplifting [pval] best 722 combination
Uplifting [ival] best 722 combination
Uplifting [printval] best 722 combination
Uplifting [incval] best 722 combination
Uplifting [printother] best 695 combination zp[1]:3 [ printother::i ]
Uplifting [main] best 695 combination zp[1]:4 [ main::i ]
Uplifting [] best 695 combination zp[1]:2 [ val ]
Uplifting [pval] best 695 combination
Uplifting [ival] best 695 combination
Uplifting [printval] best 695 combination
Uplifting [incval] best 695 combination
Attempting to uplift remaining variables inzp[1]:3 [ printother::i ]
Uplifting [printother] best 722 combination zp[1]:3 [ printother::i ]
Uplifting [printother] best 695 combination zp[1]:3 [ printother::i ]
Attempting to uplift remaining variables inzp[1]:4 [ main::i ]
Uplifting [main] best 722 combination zp[1]:4 [ main::i ]
Uplifting [main] best 695 combination zp[1]:4 [ main::i ]
Attempting to uplift remaining variables inzp[1]:2 [ val ]
Uplifting [] best 722 combination zp[1]:2 [ val ]
Uplifting [] best 695 combination zp[1]:2 [ val ]
ASSEMBLER BEFORE OPTIMIZATION
// File Comments
@ -460,16 +455,14 @@ __bbegin:
// [0] (byte) val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [1] phi from @begin to @1 [phi:@begin->@1]
__b1_from___bbegin:
jmp __b1
// @1
__b1:
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
__bend_from___b1:
jmp __bend
// @end
@ -477,106 +470,103 @@ __bend:
// printother
printother: {
.label i = 3
// [6] (byte) printother::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printother::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
jmp __b1
// printother::@1
__b1:
// [7] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) -- pbuc1_derefidx_vbuz1=_inc_pbuc1_derefidx_vbuz1
// [6] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) -- pbuc1_derefidx_vbuz1=_inc_pbuc1_derefidx_vbuz1
ldx.z i
inc SCREEN+$28,x
// [8] (byte) printother::i ← ++ (byte) printother::i -- vbuz1=_inc_vbuz1
// [7] (byte) printother::i ← ++ (byte) printother::i -- vbuz1=_inc_vbuz1
inc.z i
// [9] if((byte) printother::i!=(byte) 6) goto printother::@1 -- vbuz1_neq_vbuc1_then_la1
// [8] if((byte) printother::i!=(byte) 6) goto printother::@1 -- vbuz1_neq_vbuc1_then_la1
lda #6
cmp.z i
bne __b1
jmp __breturn
// printother::@return
__breturn:
// [10] return
// [9] return
rts
}
// incval
incval: {
// [11] (byte) val ← ++ (byte) val -- vbuz1=_inc_vbuz1
// [10] (byte) val ← ++ (byte) val -- vbuz1=_inc_vbuz1
inc.z val
jmp __breturn
// incval::@return
__breturn:
// [12] return
// [11] return
rts
}
// printval
printval: {
// [13] *((const byte*) SCREEN) ← (byte) val -- _deref_pbuc1=vbuz1
// [12] *((const byte*) SCREEN) ← (byte) val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN
jmp __breturn
// printval::@return
__breturn:
// [14] return
// [13] return
rts
}
// ival
ival: {
// [16] callprepare incval
// [17] callexecute incval -- jsr
// [14] callprepare incval
// [15] callexecute incval -- jsr
jsr incval
// [18] callfinalize incval
// [16] callfinalize incval
jmp __breturn
// ival::@return
__breturn:
// [19] return
// [17] return
rts
}
// pval
pval: {
// [21] callprepare printval
// [22] callexecute printval -- jsr
// [18] callprepare printval
// [19] callexecute printval -- jsr
jsr printval
// [23] callfinalize printval
// [20] callfinalize printval
jmp __breturn
// pval::@return
__breturn:
// [24] return
// [21] return
rts
}
// main
main: {
.label i = 4
// [25] (byte) main::i ← (byte) 0 -- vbuz1=vbuc1
// [22] (byte) main::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
// [26] phi from main main::@1 to main::@1 [phi:main/main::@1->main::@1]
__b1_from_main:
__b1_from___b1:
jmp __b1
// main::@1
__b1:
// [27] callprepare pval
// [28] callexecute pval -- jsr
// [23] callprepare pval
// [24] callexecute pval -- jsr
jsr pval
// [29] callfinalize pval
// [30] callprepare printother
// [31] callexecute printother -- jsr
// [25] callfinalize pval
// [26] callprepare printother
// [27] callexecute printother -- jsr
jsr printother
// [32] callfinalize printother
// [33] callprepare ival
// [34] callexecute ival -- jsr
// [28] callfinalize printother
// [29] callprepare ival
// [30] callexecute ival -- jsr
jsr ival
// [35] callfinalize ival
// [36] (byte) main::i ← ++ (byte) main::i -- vbuz1=_inc_vbuz1
// [31] callfinalize ival
// [32] (byte) main::i ← ++ (byte) main::i -- vbuz1=_inc_vbuz1
inc.z i
// [37] if((byte) main::i!=(byte) 6) goto main::@1 -- vbuz1_neq_vbuc1_then_la1
// [33] if((byte) main::i!=(byte) 6) goto main::@1 -- vbuz1_neq_vbuc1_then_la1
lda #6
cmp.z i
bne __b1_from___b1
bne __b1
jmp __breturn
// main::@return
__breturn:
// [38] return
// [34] return
rts
}
// File Data
@ -593,11 +583,7 @@ Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Replacing label __b1_from___b1 with __b1
Removing instruction __b1_from___bbegin:
Removing instruction __bend_from___b1:
Removing instruction __b1_from_main:
Removing instruction __b1_from___b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __b1:
Removing instruction __bend:
@ -623,7 +609,7 @@ __stackcall (void()) ival()
__stackcall (void()) main()
(label) main::@1
(label) main::@return
(byte) main::i loadstore zp[1]:4 2.6923076923076925
(byte) main::i loadstore zp[1]:4 2.9166666666666665
__stackcall (void()) printother()
(label) printother::@1
(label) printother::@return
@ -632,7 +618,7 @@ __stackcall (void()) printval()
(label) printval::@return
__stackcall (void()) pval()
(label) pval::@return
(byte) val loadstore zp[1]:2 0.26666666666666666
(byte) val loadstore zp[1]:2 0.3076923076923077
zp[1]:2 [ val ]
zp[1]:3 [ printother::i ]
@ -658,120 +644,118 @@ __bbegin:
// [0] (byte) val ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z val
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1
// [2] callprepare main
// [3] callexecute main -- jsr
// [1] callprepare main
// [2] callexecute main -- jsr
jsr main
rts
// [4] callfinalize main
// [5] phi from @1 to @end [phi:@1->@end]
// [3] callfinalize main
// [4] phi from @1 to @end [phi:@1->@end]
// @end
// printother
printother: {
.label i = 3
// for(char i:0..5)
// [6] (byte) printother::i ← (byte) 0 -- vbuz1=vbuc1
// [5] (byte) printother::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
// printother::@1
__b1:
// (SCREEN+40)[i]++;
// [7] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) -- pbuc1_derefidx_vbuz1=_inc_pbuc1_derefidx_vbuz1
// [6] *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) ← ++ *((const byte*) SCREEN+(byte) $28 + (byte) printother::i) -- pbuc1_derefidx_vbuz1=_inc_pbuc1_derefidx_vbuz1
ldx.z i
inc SCREEN+$28,x
// for(char i:0..5)
// [8] (byte) printother::i ← ++ (byte) printother::i -- vbuz1=_inc_vbuz1
// [7] (byte) printother::i ← ++ (byte) printother::i -- vbuz1=_inc_vbuz1
inc.z i
// [9] if((byte) printother::i!=(byte) 6) goto printother::@1 -- vbuz1_neq_vbuc1_then_la1
// [8] if((byte) printother::i!=(byte) 6) goto printother::@1 -- vbuz1_neq_vbuc1_then_la1
lda #6
cmp.z i
bne __b1
// printother::@return
// }
// [10] return
// [9] return
rts
}
// incval
incval: {
// val++;
// [11] (byte) val ← ++ (byte) val -- vbuz1=_inc_vbuz1
// [10] (byte) val ← ++ (byte) val -- vbuz1=_inc_vbuz1
inc.z val
// incval::@return
// }
// [12] return
// [11] return
rts
}
// printval
printval: {
// SCREEN[0] = val
// [13] *((const byte*) SCREEN) ← (byte) val -- _deref_pbuc1=vbuz1
// [12] *((const byte*) SCREEN) ← (byte) val -- _deref_pbuc1=vbuz1
lda.z val
sta SCREEN
// printval::@return
// }
// [14] return
// [13] return
rts
}
// ival
ival: {
// incval()
// [16] callprepare incval
// [17] callexecute incval -- jsr
// [14] callprepare incval
// [15] callexecute incval -- jsr
jsr incval
// [18] callfinalize incval
// [16] callfinalize incval
// ival::@return
// }
// [19] return
// [17] return
rts
}
// pval
pval: {
// printval()
// [21] callprepare printval
// [22] callexecute printval -- jsr
// [18] callprepare printval
// [19] callexecute printval -- jsr
jsr printval
// [23] callfinalize printval
// [20] callfinalize printval
// pval::@return
// }
// [24] return
// [21] return
rts
}
// main
main: {
.label i = 4
// for(char i:0..5)
// [25] (byte) main::i ← (byte) 0 -- vbuz1=vbuc1
// [22] (byte) main::i ← (byte) 0 -- vbuz1=vbuc1
lda #0
sta.z i
// [26] phi from main main::@1 to main::@1 [phi:main/main::@1->main::@1]
// main::@1
__b1:
// pval()
// [27] callprepare pval
// [28] callexecute pval -- jsr
// [23] callprepare pval
// [24] callexecute pval -- jsr
jsr pval
// [29] callfinalize pval
// [25] callfinalize pval
// printother()
// [30] callprepare printother
// [31] callexecute printother -- jsr
// [26] callprepare printother
// [27] callexecute printother -- jsr
jsr printother
// [32] callfinalize printother
// [28] callfinalize printother
// ival()
// [33] callprepare ival
// [34] callexecute ival -- jsr
// [29] callprepare ival
// [30] callexecute ival -- jsr
jsr ival
// [35] callfinalize ival
// [31] callfinalize ival
// for(char i:0..5)
// [36] (byte) main::i ← ++ (byte) main::i -- vbuz1=_inc_vbuz1
// [32] (byte) main::i ← ++ (byte) main::i -- vbuz1=_inc_vbuz1
inc.z i
// [37] if((byte) main::i!=(byte) 6) goto main::@1 -- vbuz1_neq_vbuc1_then_la1
// [33] if((byte) main::i!=(byte) 6) goto main::@1 -- vbuz1_neq_vbuc1_then_la1
lda #6
cmp.z i
bne __b1
// main::@return
// }
// [38] return
// [34] return
rts
}
// File Data

4
src/test/ref/procedure-callingconvention-stack-9.sym
View File

@ -9,7 +9,7 @@ __stackcall (void()) ival()
__stackcall (void()) main()
(label) main::@1
(label) main::@return
(byte) main::i loadstore zp[1]:4 2.6923076923076925
(byte) main::i loadstore zp[1]:4 2.9166666666666665
__stackcall (void()) printother()
(label) printother::@1
(label) printother::@return
@ -18,7 +18,7 @@ __stackcall (void()) printval()
(label) printval::@return
__stackcall (void()) pval()
(label) pval::@return
(byte) val loadstore zp[1]:2 0.26666666666666666
(byte) val loadstore zp[1]:2 0.3076923076923077
zp[1]:2 [ val ]
zp[1]:3 [ printother::i ]