From eb69af8fe7b6f14124167854cfadcf36fe4897ee Mon Sep 17 00:00:00 2001 From: jespergravgaard Date: Sun, 23 Apr 2023 20:54:22 +0200 Subject: [PATCH] Refactored calling convention. --- .../AsmFragmentInstanceSpecBuilder.java | 18 ++++++++------ .../signature/AsmFragmentSignature.java | 12 ++++------ .../kickc/model/symbols/Procedure.java | 24 +++++++++++++++---- .../kickc/passes/Pass4CodeGeneration.java | 2 +- 4 files changed, 36 insertions(+), 20 deletions(-) diff --git a/src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstanceSpecBuilder.java b/src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstanceSpecBuilder.java index 30afba97c..280c4811d 100644 --- a/src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstanceSpecBuilder.java +++ b/src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstanceSpecBuilder.java @@ -44,17 +44,21 @@ final public class AsmFragmentInstanceSpecBuilder { } /** - * Create a fragment instance spec factory for a subroutine call + * Create a fragment instance spec factory for a banked call * - * @param callingDistance The class expressing the distance of the call: "near", "close", "far" plus bankArea and bank information calculated from the from and to procedure. - * @param callingConvention The string expressing the calling convention supported by the fragment. - * @param procedureName The full name of the procedure. - * @param program The program + * @param callingConvention The calling convention + * @param proximity The calling distance of the call + * @param toBank The bank of the procedure being called + * @param procedureName The full name of the procedure being called. + * @param program The program * @return the fragment instance spec factory */ - public static AsmFragmentInstanceSpec callBanked(String callingConvention, Procedure.CallingProximity proximity, Bank toBank, String procedureName, Program program) { + public static AsmFragmentInstanceSpec callBanked(Procedure.CallingConvention callingConvention, Procedure.CallingProximity proximity, Bank toBank, String procedureName, Program program) { AsmFragmentBindings bindings = new AsmFragmentBindings(program); - AsmFragmentSignature signature = new AsmFragmentSignature.CallBanked(callingConvention, proximity, toBank); + AsmFragmentSignature signature = new AsmFragmentSignature.CallBanked( + callingConvention.getShortName(), + proximity.toString(), + (proximity.equals(Procedure.CallingProximity.NEAR)?null:toBank.bankArea())); ScopeRef codeScope = program.getScope().getRef(); bindings.bind("c1", new ConstantInteger(toBank.bankNumber())); bindings.bind("la1", new LabelRef(procedureName)); diff --git a/src/main/java/dk/camelot64/kickc/fragment/signature/AsmFragmentSignature.java b/src/main/java/dk/camelot64/kickc/fragment/signature/AsmFragmentSignature.java index 4b37b89a5..1a4a3f596 100644 --- a/src/main/java/dk/camelot64/kickc/fragment/signature/AsmFragmentSignature.java +++ b/src/main/java/dk/camelot64/kickc/fragment/signature/AsmFragmentSignature.java @@ -2,8 +2,6 @@ package dk.camelot64.kickc.fragment.signature; import dk.camelot64.kickc.asm.fragment.signature.AsmFragmentSignatureLexer; import dk.camelot64.kickc.asm.fragment.signature.AsmFragmentSignatureParser; -import dk.camelot64.kickc.model.symbols.Bank; -import dk.camelot64.kickc.model.symbols.Procedure; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; @@ -79,19 +77,19 @@ public interface AsmFragmentSignature { final private String callingConvention; - final private Procedure.CallingProximity proximity; + final private String proximity; - final private Bank toBank; + final private String toBankArea; - public CallBanked(String callingConvention, Procedure.CallingProximity proximity, Bank toBank) { + public CallBanked(String callingConvention, String proximity, String toBankArea) { this.callingConvention = callingConvention; this.proximity = proximity; - this.toBank = toBank; + this.toBankArea = toBankArea; } @Override public String getName() { - return "call_" + callingConvention.toLowerCase() + "_" + proximity.toString().toLowerCase() + (proximity.equals(Procedure.CallingProximity.NEAR)?"":("_"+toBank.bankArea())); + return "call_" + callingConvention + "_" + proximity + ((toBankArea==null)?"":("_"+toBankArea)); } } diff --git a/src/main/java/dk/camelot64/kickc/model/symbols/Procedure.java b/src/main/java/dk/camelot64/kickc/model/symbols/Procedure.java index 4252fb9d6..ac2599c55 100644 --- a/src/main/java/dk/camelot64/kickc/model/symbols/Procedure.java +++ b/src/main/java/dk/camelot64/kickc/model/symbols/Procedure.java @@ -74,6 +74,7 @@ public class Procedure extends Scope { /** A trampoline bank change is needed. Caller and callee are different banks of the same banking area. */ FAR; + public static CallingProximity forCall(Bank from, Bank to) { if(to==null) { // NEAR: call to the common bank @@ -92,29 +93,42 @@ public class Procedure extends Scope { return FAR; } } + + @Override + public String toString() { + return name().toLowerCase(); + } + } /** The method for passing parameters and return value to the procedure. */ public enum CallingConvention { /** Parameters and return value handled through PHI-transitions. */ - PHI_CALL("__phicall"), + PHI_CALL("__phicall", "phi"), /** Parameters and return value over the stack. */ - STACK_CALL("__stackcall"), + STACK_CALL("__stackcall", "stack"), /** Parameters and return value handled through shared variables. */ - VAR_CALL("__varcall"), + VAR_CALL("__varcall", "var"), /** Intrinsic calling. Will be converted to intrinsic ASM late in the compile. */ - INTRINSIC_CALL("__intrinsiccall"); + INTRINSIC_CALL("__intrinsiccall", "intrinsic"); private final String name; - CallingConvention(String name) { + private final String shortName; + + CallingConvention(String name, String shortName) { this.name = name; + this.shortName = shortName; } public String getName() { return name; } + public String getShortName() { + return shortName; + } + /** Get a calling convention by name. */ public static CallingConvention getCallingConvension(String name) { for(CallingConvention value : CallingConvention.values()) { diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java b/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java index 2211d4fd1..81fefaad9 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java @@ -905,7 +905,7 @@ public class Pass4CodeGeneration { if(Procedure.CallingProximity.NEAR.equals(callingProximity)) { asm.addInstruction("jsr", CpuAddressingMode.ABS, call.getProcedure().getFullName(), false); } else { - AsmFragmentCodeGenerator.generateAsm(asm, AsmFragmentInstanceSpecBuilder.callBanked("phi", callingProximity, toProcedure.getBank(), call.getProcedure().getFullName(), program), program); + AsmFragmentCodeGenerator.generateAsm(asm, AsmFragmentInstanceSpecBuilder.callBanked(Procedure.CallingConvention.PHI_CALL, callingProximity, toProcedure.getBank(), call.getProcedure().getFullName(), program), program); } } else if (Procedure.CallingConvention.STACK_CALL.equals(toProcedure.getCallingConvention())) { final Procedure.CallingProximity callingProximity = Procedure.CallingProximity.forCall(fromProcedure.getBank(), toProcedure.getBank());