From 9b41df3b6a8ea7b145664fa845c8edb0a70e68f7 Mon Sep 17 00:00:00 2001 From: jespergravgaard Date: Fri, 27 Mar 2020 10:53:42 +0100 Subject: [PATCH] Added variable layer handling to declarations. --- .../Pass0GenerateStatementSequence.java | 208 +++++++++---- .../dk/camelot64/kickc/test/TestPrograms.java | 5 + src/test/kc/comma-decl-2.kc | 9 + src/test/ref/comma-decl-2.asm | 21 ++ src/test/ref/comma-decl-2.cfg | 19 ++ src/test/ref/comma-decl-2.log | 274 ++++++++++++++++++ src/test/ref/comma-decl-2.sym | 10 + 7 files changed, 489 insertions(+), 57 deletions(-) create mode 100644 src/test/kc/comma-decl-2.kc create mode 100644 src/test/ref/comma-decl-2.asm create mode 100644 src/test/ref/comma-decl-2.cfg create mode 100644 src/test/ref/comma-decl-2.log create mode 100644 src/test/ref/comma-decl-2.sym diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java b/src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java index cbcf1f57a..868360ad7 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java @@ -207,8 +207,8 @@ public class Pass0GenerateStatementSequence extends KickCParserBaseVisitor directives = declVarDirectives; + SymbolType type = varDecl.getEffectiveType(); + List directives = varDecl.getEffectiveDirectives(); String name = ctx.NAME().getText(); Procedure procedure = getCurrentScope().addProcedure(name, type, currentCodeSegment, currentDataSegment, currentCallingConvention); addDirectives(procedure, directives, StatementSource.procedureBegin(ctx)); @@ -245,7 +245,8 @@ public class Pass0GenerateStatementSequence extends KickCParserBaseVisitor declVarDirectives = null; - /** Holds the declared comments when descending into a Variable Declaration. */ - private List declVarComments = null; - /** State specifying that we are currently populating struct members. */ - private boolean declVarStructMember = false; + /** + * Holds type, arrayness, directives, comments etc. while parsing a variable declaration. + * Has three levels of information pushed on top of each other: + *
    + *
  1. Struct Member Declaration (true while inside inside a struct declaration)
    2. + *
  2. Type information and directives (the type)
    3. + *
  3. Variable information and declarations (arrayness, pointerness, variable level directives)
    4. + *
+ *

+ * When parsing a declaration such as volatile char a, * const b, c[] the type level holds volatile char + * and the variable level holds the pointer/array-information and the const-declaration for b. + */ + static class VariableDeclaration { + + /** State specifying that we are currently populating struct members. */ + private boolean structMember = false; + + /** Holds the declared type (type level). */ + private SymbolType type = null; + /** Holds the information about whether the declared variable is an array and the size of the array if it is (type level). */ + private ArraySpec arraySpec; + /** Holds the declared directives when descending into a Variable Declaration. (type level) */ + private List directives = null; + /** Holds the declared comments when descending into a Variable Declaration. (type level) */ + private List comments = null; + + /** Holds the type when diving into a single variable. (variable level) */ + private SymbolType varType = null; + /** Holds the array information for a single variable. (variable level) */ + private ArraySpec varArraySpec; + /** Holds the declared directives for a single variable. (variable level) */ + private List varDirectives = null; + + public VariableDeclaration() { + } + + /** + * Exits the type layer (clears everyting except struct information) + */ + public void exitType() { + this.type = null; + this.directives = null; + this.arraySpec = null; + this.comments = null; + } + + /** + * Exits the variable layer (clears variable information) + */ + public void exitVar() { + this.varType = null; + this.varArraySpec = null; + this.varDirectives = null; + } + + public SymbolType getEffectiveType() { + return varType != null ? varType : type; + } + + public ArraySpec getEffectiveArraySpec() { + return varArraySpec != null ? varArraySpec : arraySpec; + } + + public List getEffectiveDirectives() { + final ArrayList dirs = new ArrayList<>(); + if(directives != null) + dirs.addAll(directives); + if(varDirectives != null) + dirs.addAll(varDirectives); + return dirs; + } + + public List getComments() { + return comments; + } + + public boolean isStructMember() { + return structMember; + } + + public void setType(SymbolType type) { + this.type = type; + } + + public void setArraySpec(ArraySpec arraySpec) { + this.arraySpec = arraySpec; + } + + public void setDirectives(List directives) { + this.directives = directives; + } + + public void setComments(List comments) { + this.comments = comments; + } + + public void setStructMember(boolean structMember) { + this.structMember = structMember; + } + + public void setVarArraySpec(ArraySpec varArraySpec) { + this.varArraySpec = varArraySpec; + } + + public void setVarType(SymbolType varType) { + this.varType = varType; + } + } + + private VariableDeclaration varDecl = new VariableDeclaration(); /** * Visit the type/directive part of a declaration. Setup the local decl-variables @@ -532,27 +634,18 @@ public class Pass0GenerateStatementSequence extends KickCParserBaseVisitor directive = ctx.directive(); - this.declVarType = (SymbolType) visit(ctx.typeDecl()); - this.declVarDirectives = getDirectives(directive); - this.declVarComments = getCommentsSymbol(ctx.getParent()); + varDecl.exitType(); + varDecl.setType((SymbolType) visit(ctx.typeDecl())); + varDecl.setDirectives(getDirectives(directive)); + varDecl.setComments(getCommentsSymbol(ctx.getParent())); return null; } - /** - * Clear the local decl-variables - */ - private void exitDeclTypes() { - this.declVarType = null; - this.declVarDirectives = null; - this.declVarComments = null; - this.declArraySpec = null; - } - @Override public Object visitDeclVariables(KickCParser.DeclVariablesContext ctx) { this.visit(ctx.declTypes()); this.visit(ctx.declVariableList()); - exitDeclTypes(); + varDecl.exitType(); return null; } @@ -572,23 +665,23 @@ public class Pass0GenerateStatementSequence extends KickCParserBaseVisitor@1] +__b1_from___bbegin: + jmp __b1 + // @1 +__b1: + // [2] call main + jsr main + // [3] phi from @1 to @end [phi:@1->@end] +__bend_from___b1: + jmp __bend + // @end +__bend: + // main +main: { + .label SCREEN = $400 + .const b = 0 + .const d = 0 + // [4] *((const byte*) main::SCREEN) ← (const byte) main::b -- _deref_pbuc1=vbuc2 + lda #b + sta SCREEN + // [5] *((const byte*) main::SCREEN+(byte) 1) ← *((const byte*) main::c) -- _deref_pbuc1=_deref_pbuc2 + lda c + sta SCREEN+1 + // [6] *((const byte*) main::SCREEN+(byte) 2) ← (const byte) main::d -- _deref_pbuc1=vbuc2 + lda #d + sta SCREEN+2 + jmp __breturn + // main::@return + __breturn: + // [7] return + rts + c: .fill 3, 0 +} + // File Data + +REGISTER UPLIFT POTENTIAL REGISTERS +Statement [4] *((const byte*) main::SCREEN) ← (const byte) main::b [ ] ( main:2 [ ] { } ) always clobbers reg byte a +Statement [5] *((const byte*) main::SCREEN+(byte) 1) ← *((const byte*) main::c) [ ] ( main:2 [ ] { } ) always clobbers reg byte a +Statement [6] *((const byte*) main::SCREEN+(byte) 2) ← (const byte) main::d [ ] ( main:2 [ ] { } ) always clobbers reg byte a + +REGISTER UPLIFT SCOPES +Uplift Scope [main] +Uplift Scope [] + +Uplifting [main] best 41 combination +Uplifting [] best 41 combination + +ASSEMBLER BEFORE OPTIMIZATION + // File Comments +// Tests comma-separated declarations with different array-ness + // Upstart +.pc = $801 "Basic" +:BasicUpstart(__bbegin) +.pc = $80d "Program" + // Global Constants & labels + // @begin +__bbegin: + // [1] phi from @begin to @1 [phi:@begin->@1] +__b1_from___bbegin: + jmp __b1 + // @1 +__b1: + // [2] call main + jsr main + // [3] phi from @1 to @end [phi:@1->@end] +__bend_from___b1: + jmp __bend + // @end +__bend: + // main +main: { + .label SCREEN = $400 + .const b = 0 + .const d = 0 + // [4] *((const byte*) main::SCREEN) ← (const byte) main::b -- _deref_pbuc1=vbuc2 + lda #b + sta SCREEN + // [5] *((const byte*) main::SCREEN+(byte) 1) ← *((const byte*) main::c) -- _deref_pbuc1=_deref_pbuc2 + lda c + sta SCREEN+1 + // [6] *((const byte*) main::SCREEN+(byte) 2) ← (const byte) main::d -- _deref_pbuc1=vbuc2 + lda #d + sta SCREEN+2 + jmp __breturn + // main::@return + __breturn: + // [7] return + rts + c: .fill 3, 0 +} + // File Data + +ASSEMBLER OPTIMIZATIONS +Removing instruction jmp __b1 +Removing instruction jmp __bend +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 +Removing instruction __bend: +Removing instruction __breturn: +Succesful ASM optimization Pass5UnusedLabelElimination +Updating BasicUpstart to call main directly +Removing instruction jsr main +Succesful ASM optimization Pass5SkipBegin +Removing instruction __bbegin: +Succesful ASM optimization Pass5UnusedLabelElimination + +FINAL SYMBOL TABLE +(label) @1 +(label) @begin +(label) @end +(void()) main() +(label) main::@return +(const byte*) main::SCREEN = (byte*) 1024 +(const byte) main::b = (byte) 0 +(const byte*) main::c[(number) 3] = { fill( 3, 0) } +(const byte) main::d = (byte) 0 + + + +FINAL ASSEMBLER +Score: 26 + + // File Comments +// Tests comma-separated declarations with different array-ness + // Upstart +.pc = $801 "Basic" +:BasicUpstart(main) +.pc = $80d "Program" + // Global Constants & labels + // @begin + // [1] phi from @begin to @1 [phi:@begin->@1] + // @1 + // [2] call main + // [3] phi from @1 to @end [phi:@1->@end] + // @end + // main +main: { + .label SCREEN = $400 + .const b = 0 + .const d = 0 + // SCREEN[0] = b + // [4] *((const byte*) main::SCREEN) ← (const byte) main::b -- _deref_pbuc1=vbuc2 + lda #b + sta SCREEN + // SCREEN[1] = c[0] + // [5] *((const byte*) main::SCREEN+(byte) 1) ← *((const byte*) main::c) -- _deref_pbuc1=_deref_pbuc2 + lda c + sta SCREEN+1 + // SCREEN[2] = d + // [6] *((const byte*) main::SCREEN+(byte) 2) ← (const byte) main::d -- _deref_pbuc1=vbuc2 + lda #d + sta SCREEN+2 + // main::@return + // } + // [7] return + rts + c: .fill 3, 0 +} + // File Data + diff --git a/src/test/ref/comma-decl-2.sym b/src/test/ref/comma-decl-2.sym new file mode 100644 index 000000000..7eca39bf6 --- /dev/null +++ b/src/test/ref/comma-decl-2.sym @@ -0,0 +1,10 @@ +(label) @1 +(label) @begin +(label) @end +(void()) main() +(label) main::@return +(const byte*) main::SCREEN = (byte*) 1024 +(const byte) main::b = (byte) 0 +(const byte*) main::c[(number) 3] = { fill( 3, 0) } +(const byte) main::d = (byte) 0 +