Implemented coalescing for main memory PHI registers.

src/main/java/dk/camelot64/kickc/Compiler.java

@@ -589,14 +589,14 @@ public class Compiler {
       }
 
       // Register coalesce on assignment (saving bytes & cycles)
-      new Pass4ZeroPageCoalesceAssignment(program).coalesce();
+      new Pass4MemoryCoalesceAssignment(program).coalesce();
 
       // Register coalesce on call graph (saving ZP)
-      new Pass4ZeroPageCoalesceCallGraph(program).coalesce();
+      new Pass4MemoryCoalesceCallGraph(program).coalesce();
 
       if(enableZeroPageCoalasce) {
          // Register coalesce using exhaustive search (saving even more ZP - but slow)
-         new Pass4ZeroPageCoalesceExhaustive(program).coalesce();
+         new Pass4MemoryCoalesceExhaustive(program).coalesce();
       }
       new Pass4RegistersFinalize(program).allocate(true);
       new Pass4AssertZeropageAllocation(program).check();

src/main/java/dk/camelot64/kickc/model/DirectiveParserContext.java

@@ -134,8 +134,10 @@ public class DirectiveParserContext {
       this.registerImpliesDirectives = new ArrayList<>();
       this.typeDirectives = new HashMap<>();
       this.typeDirectives.put(DirectiveType.ARRAY, Arrays.asList(new Directive.Const(), new Directive.MemoryArea(SymbolVariable.MemoryArea.MAIN_MEMORY, null), new Directive.Register(false, null)));
+      //this.typeDirectives.put(DirectiveType.POINTER, Arrays.asList(new Directive.MemoryArea(SymbolVariable.MemoryArea.ZEROPAGE_MEMORY, null)));
       this.scopeDirectives = new HashMap<>();
       this.scopeTypeDirectives = new HashMap<>();
+      //this.scopeDirectives.put(DirectiveScope.GLOBAL, Arrays.asList(new Directive.MemoryArea(SymbolVariable.MemoryArea.MAIN_MEMORY, null)));
    }
 
    /**

src/main/java/dk/camelot64/kickc/model/values/ZeroConstantValues.java

@@ -25,6 +25,8 @@ public class ZeroConstantValues {
             zeroValues.put(memberVar.getRef(), zeroValue(memberVar.getType(), programScope));
          }
          return new ConstantStructValue(typeStruct, zeroValues);
+      } else if(type.equals(SymbolType.BOOLEAN)) {
+         return new ConstantBool(false);
       } else if(type instanceof SymbolTypeIntegerFixed) {
          return new ConstantInteger(0L, type);
       } else if(type instanceof SymbolTypePointer) {

src/main/java/dk/camelot64/kickc/passes/Pass3PhiMemCoalesce.java

@@ -6,6 +6,7 @@ import dk.camelot64.kickc.model.LiveRangeEquivalenceClassSet;
 import dk.camelot64.kickc.model.Program;
 import dk.camelot64.kickc.model.statements.StatementAssignment;
 import dk.camelot64.kickc.model.statements.StatementPhiBlock;
+import dk.camelot64.kickc.model.symbols.Variable;
 import dk.camelot64.kickc.model.types.SymbolType;
 import dk.camelot64.kickc.model.values.ConstantValue;
 import dk.camelot64.kickc.model.values.VariableRef;
@@ -72,10 +73,16 @@ public class Pass3PhiMemCoalesce extends Pass2SsaOptimization {
                   VariableRef phiRVar = (VariableRef) phiRValue.getrValue();
                   LiveRangeEquivalenceClass rValEquivalenceClass = phiEquivalenceClasses.getOrCreateEquivalenceClass(phiRVar);
                   if(!rValEquivalenceClass.equals(equivalenceClass)) {
-                     SymbolType varType = program.getScope().getVariable(variable).getType();
+                     Variable var = program.getScope().getVariable(variable);
-                     SymbolType rVarType = program.getScope().getVariable(phiRVar).getType();
+                     Variable rVar = program.getScope().getVariable(phiRVar);
+                     SymbolType varType = var.getType();
+                     SymbolType rVarType = rVar.getType();
                      if(varType.getSizeBytes()==rVarType.getSizeBytes()) {
-                        phiEquivalenceClasses.consolidate(equivalenceClass, rValEquivalenceClass);
+                        if(var.getMemoryArea().equals(rVar.getMemoryArea())) {
+                           phiEquivalenceClasses.consolidate(equivalenceClass, rValEquivalenceClass);
+                        } else {
+                           program.getLog().append("Not consolidating phi with different storage strategy "+variable.toString()+" "+phiRVar.toString());
+                        }
                      } else {
                         program.getLog().append("Not consolidating phi with different size "+variable.toString()+" "+phiRVar.toString());
                      }

src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java

@@ -465,27 +465,46 @@ public class Pass4CodeGeneration {
       // Add all memory variables
       Collection<Variable> scopeVariables = scope.getAllVariables(false);
       for(Variable variable : scopeVariables) {
-         if(variable.isStorageLoadStore() && variable.isMemoryAreaMain()) {
+         if(variable.isMemoryAreaMain()) {
+            // Skip PHI masters
+            if(variable.isStoragePhiMaster())
+               continue;
             // Skip if already added
             String asmName = variable.getAsmName() == null ? variable.getLocalName() : variable.getAsmName();
             if(added.contains(asmName)) {
                continue;
             }
-            if(variable.getDeclaredMemoryAddress() == null) {
+            if(variable.isStorageLoadStore() || variable.isStoragePhiVersion() || variable.isStorageIntermediate()){
-               // Generate into the data segment
+               if(variable.getDeclaredMemoryAddress() == null) {
-               // Set segment
+
-               setCurrentSegment(variable.getDataSegment(), asm);
+                  Registers.Register allocation = variable.getAllocation();
-               // Add any comments
+                  if(!(allocation instanceof Registers.RegisterMainMem)) {
-               generateComments(asm, variable.getComments());
+                     throw new InternalError("Expected main memory allocation "+variable.toString(program));
-               // Add any alignment
+                  }
-               Integer declaredAlignment = variable.getDeclaredAlignment();
+                  Registers.RegisterMainMem registerMainMem = (Registers.RegisterMainMem) allocation;
-               if(declaredAlignment != null) {
+                  if(!((Registers.RegisterMainMem) allocation).getVariableRef().equals(variable.getRef())) {
-                  String alignment = AsmFormat.getAsmNumber(declaredAlignment);
+                     continue;
-                  asm.addDataAlignment(alignment);
+                  }
+
+
+
+                  // Generate into the data segment
+                  // Set segment
+                  setCurrentSegment(variable.getDataSegment(), asm);
+                  // Add any comments
+                  generateComments(asm, variable.getComments());
+                  // Add any alignment
+                  Integer declaredAlignment = variable.getDeclaredAlignment();
+                  if(declaredAlignment != null) {
+                     String alignment = AsmFormat.getAsmNumber(declaredAlignment);
+                     asm.addDataAlignment(alignment);
+                  }
+                  AsmDataChunk asmDataChunk = new AsmDataChunk();
+                  addChunkData(asmDataChunk, ZeroConstantValues.zeroValue(variable.getType(), getScope()), variable.getType(), scopeRef);
+                  asmDataChunk.addToAsm(AsmFormat.asmFix(asmName), asm);
                }
-               AsmDataChunk asmDataChunk = new AsmDataChunk();
+            } else {
-               addChunkData(asmDataChunk, ZeroConstantValues.zeroValue(variable.getType(), getScope()), variable.getType(), scopeRef);
+               throw new InternalError("Not handled variable storage "+variable.toString());
-               asmDataChunk.addToAsm(AsmFormat.asmFix(asmName), asm);
             }
             added.add(asmName);
          }
@@ -632,6 +651,8 @@ public class Pass4CodeGeneration {
          dataChunk.addDataNumeric(AsmDataNumeric.Type.DWORD, AsmFormat.getAsmConstant(program, value, 99, scopeRef), getEncoding(value));
       } else if(valueType instanceof SymbolTypePointer) {
          dataChunk.addDataNumeric(AsmDataNumeric.Type.WORD, AsmFormat.getAsmConstant(program, value, 99, scopeRef), getEncoding(value));
+      } else if(SymbolType.BOOLEAN.equals(valueType)) {
+         dataChunk.addDataNumeric(AsmDataNumeric.Type.BYTE, AsmFormat.getAsmConstant(program, value, 99, scopeRef), getEncoding(value));
       } else {
          throw new InternalError("Unhandled array element type " + valueType.toString() + " value " + value.toString(program));
       }
@@ -688,6 +709,20 @@ public class Pass4CodeGeneration {
                   asm.addLabelDecl(AsmFormat.asmFix(asmName), AsmFormat.getAsmNumber(scopeVar.getDeclaredMemoryAddress()));
                   added.add(asmName);
                }
+            } else if(register instanceof Registers.RegisterMainMem && !((Registers.RegisterMainMem) register).getVariableRef().equals(scopeVar.getRef())) {
+               // Memory variable is not main var in the equivalence class - add a reference
+               String asmName = scopeVar.getAsmName();
+               Registers.RegisterMainMem memAllocation = (Registers.RegisterMainMem) register;
+               VariableRef memAllocationVarRef = memAllocation.getVariableRef();
+               Variable memAllocationVar = getScope().getVariable(memAllocationVarRef);
+               // Add the label declaration
+               String asmNameMemAllocVar = AsmFormat.getAsmParamName(memAllocationVar, scope);
+               if(!asmName.equals(asmNameMemAllocVar)) {
+                  // Add any comments
+                  generateComments(asm, scopeVar.getComments());
+                  asm.addLabelDecl(AsmFormat.asmFix(asmName), asmNameMemAllocVar);
+                  added.add(asmName);
+               }
             }
       }
    }

src/main/java/dk/camelot64/kickc/passes/Pass4MemoryCoalesce.java

@@ -14,12 +14,12 @@ import java.util.List;
 import java.util.Set;
 
 /**
- * Coalesces zero page registers where their live ranges do not overlap.
+ * Coalesces memory registers where their live ranges do not overlap.
  * A final step done after all other register optimizations and before ASM generation.
  */
-public abstract class Pass4ZeroPageCoalesce extends Pass2Base {
+public abstract class Pass4MemoryCoalesce extends Pass2Base {
 
-   public Pass4ZeroPageCoalesce(Program program) {
+   public Pass4MemoryCoalesce(Program program) {
       super(program);
    }
 
@@ -57,6 +57,7 @@ public abstract class Pass4ZeroPageCoalesce extends Pass2Base {
    static boolean canCoalesce(LiveRangeEquivalenceClass ec1, LiveRangeEquivalenceClass ec2, Collection<ScopeRef> threadHeads, Set<String> unknownFragments, Program program) {
       return
             canCoalesceNotEqual(ec1, ec2) &&
+                  canCoalesceCompatible(ec1, ec2, program) &&
                   canCoalesceVolatile(ec1, ec2, program) &&
                   canCoalesceThreads(ec1, ec2, threadHeads, program) &&
                   canCoalesceClobber(ec1, ec2, unknownFragments, program);
@@ -129,6 +130,30 @@ public abstract class Pass4ZeroPageCoalesce extends Pass2Base {
       return threads;
    }
 
+   /**
+    * Determines if two live range equivalence classes have compatible registers.
+    * The registers are compatible if they are in memory and have the same type and size.
+    *
+    * @param ec1 One equivalence class
+    * @param ec2 Another equivalence class
+    * @param program The program
+    * @return True if the two equivalence classes can be coalesced into one without problems.
+    */
+   private static boolean canCoalesceCompatible(LiveRangeEquivalenceClass ec1, LiveRangeEquivalenceClass ec2, Program program) {
+      Registers.Register register1 = ec1.getRegister();
+      Registers.Register register2 = ec2.getRegister();
+      // Check the both registers are in memory
+      if(!register1.isMem() || !register2.isMem())
+         return false;
+      // Check the both registers have the same type
+      if(!register1.getType().equals(register2.getType()))
+         return false;
+      // Check the both registers have the same size
+      if(register1.getBytes() != register2.getBytes())
+         return false;
+      return true;
+   }
+
    /**
     * Determines if two live range equivalence classes can be coalesced without clobber.
     * This is possible if they are both allocated to zero page, have the same size and the resulting ASM has no live range overlaps or clobber issues.
@@ -141,15 +166,10 @@ public abstract class Pass4ZeroPageCoalesce extends Pass2Base {
     */
    private static boolean canCoalesceClobber(LiveRangeEquivalenceClass ec1, LiveRangeEquivalenceClass ec2, Set<String> unknownFragments, Program program) {
       Registers.Register register1 = ec1.getRegister();
-      Registers.Register register2 = ec2.getRegister();
+      // Try out the coalesce to test if it works
-      if(register1.isZp() && register2.isZp() && register1.getBytes()==register2.getBytes()) {
+      RegisterCombination combination = new RegisterCombination();
-         // Both registers are on Zero Page & have the same zero page size
+      combination.setRegister(ec2, register1);
-         // Try out the coalesce to test if it works
+      return Pass4RegisterUpliftCombinations.generateCombinationAsm(combination, program, unknownFragments, ScopeRef.ROOT);
-         RegisterCombination combination = new RegisterCombination();
-         combination.setRegister(ec2, register1);
-         return Pass4RegisterUpliftCombinations.generateCombinationAsm(combination, program, unknownFragments, ScopeRef.ROOT);
-      }
-      return false;
    }
 
    /**
@@ -192,7 +212,7 @@ public abstract class Pass4ZeroPageCoalesce extends Pass2Base {
       List<LiveRangeEquivalenceClass> equivalenceClasses = liveRangeEquivalenceClassSet.getEquivalenceClasses();
       if(equivalenceClasses.contains(candidate.getEc1()) && equivalenceClasses.contains(candidate.getEc2())) {
          // Both equivalence classes still exist
-         if(Pass4ZeroPageCoalesce.canCoalesce(candidate.getEc1(), candidate.getEc2(), threadHeads, unknownFragments, program)) {
+         if(Pass4MemoryCoalesce.canCoalesce(candidate.getEc1(), candidate.getEc2(), threadHeads, unknownFragments, program)) {
             String scoreString = (candidate.getScore() == null) ? "" : (" - score: " + candidate.getScore());
             program.getLog().append("Coalescing zero page register [ " + candidate.getEc1() + " ] with [ " + candidate.getEc2() + " ]" + scoreString);
             liveRangeEquivalenceClassSet.consolidate(candidate.getEc1(), candidate.getEc2());

src/main/java/dk/camelot64/kickc/passes/Pass4MemoryCoalesceAssignment.java

@@ -8,29 +8,29 @@ import dk.camelot64.kickc.model.statements.Statement;
 import java.util.*;
 
 /**
- * Coalesces zero page registers where their live ranges do not overlap.
+ * Coalesces memory registers where their live ranges do not overlap.
  * This step tries to coalesce lvalues with rvalues for all assignments - saving both cycles & bytes if successful.
  */
-public class Pass4ZeroPageCoalesceAssignment extends Pass2Base {
+public class Pass4MemoryCoalesceAssignment extends Pass2Base {
 
-   public Pass4ZeroPageCoalesceAssignment(Program program) {
+   public Pass4MemoryCoalesceAssignment(Program program) {
       super(program);
    }
 
    public void coalesce() {
       CoalesceVarScores coalesceVarScores = new CoalesceVarScores(getProgram());
       LinkedHashSet<String> unknownFragments = new LinkedHashSet<>();
-      Collection<ScopeRef> threadHeads = Pass4ZeroPageCoalesce.getThreadHeads(getProgram());
+      Collection<ScopeRef> threadHeads = Pass4MemoryCoalesce.getThreadHeads(getProgram());
 
       boolean change;
       do {
          change = false;
          CoalesceLiveRangeEquivalenceClassScores equivalenceClassScores =
                new CoalesceLiveRangeEquivalenceClassScores(getProgram(), coalesceVarScores);
-         List<Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate> coalesceCandidates =
+         List<Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate> coalesceCandidates =
                equivalenceClassScores.getCoalesceCandidates();
-         for(Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate : coalesceCandidates) {
+         for(Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate : coalesceCandidates) {
-            change |= Pass4ZeroPageCoalesce.attemptCoalesce(candidate, threadHeads, unknownFragments, getProgram());
+            change |= Pass4MemoryCoalesce.attemptCoalesce(candidate, threadHeads, unknownFragments, getProgram());
          }
       } while(change);
 
@@ -147,14 +147,14 @@ public class Pass4ZeroPageCoalesceAssignment extends Pass2Base {
        *
        * @return candidate pairs of live range equivalence classes for coalescing with a positive score
        */
-      public List<Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate> getCoalesceCandidates() {
+      public List<Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate> getCoalesceCandidates() {
-         ArrayList<Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate> candidates = new ArrayList<>();
+         ArrayList<Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate> candidates = new ArrayList<>();
          for(LiveRangeEquivalenceClass ec1 : scores.keySet()) {
             Map<LiveRangeEquivalenceClass, Integer> ec1Scores = scores.get(ec1);
             for(LiveRangeEquivalenceClass ec2 : ec1Scores.keySet()) {
                Integer score = ec1Scores.get(ec2);
-               Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate =
+               Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate =
-                     new Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate(ec1, ec2, score);
+                     new Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate(ec1, ec2, score);
                if(!candidates.contains(candidate)) {
                   candidates.add(candidate);
                }

src/main/java/dk/camelot64/kickc/passes/Pass4MemoryCoalesceCallGraph.java

@@ -10,22 +10,22 @@ import dk.camelot64.kickc.model.values.VariableRef;
 import java.util.*;
 
 /**
- * Use the call graph to coalesce zero page registers.
+ * Use the call graph to coalesce memory registers.
  * For each live range equivalence class:
  *  - Look up through the call graph and avoid all variables declared in the scopes there
  *  - Go through already handled live range equivalence classes and if any exist with no scope overlap with the call graph - try to coalesce
  *  - Add to the list of already handled live range equivalence classes
  */
-public class Pass4ZeroPageCoalesceCallGraph extends Pass2Base {
+public class Pass4MemoryCoalesceCallGraph extends Pass2Base {
 
-   public Pass4ZeroPageCoalesceCallGraph(Program program) {
+   public Pass4MemoryCoalesceCallGraph(Program program) {
       super(program);
    }
 
    public void coalesce() {
       LinkedHashSet<String> unknownFragments = new LinkedHashSet<>();
       LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet = getProgram().getLiveRangeEquivalenceClassSet();
-      Collection<ScopeRef> threads = Pass4ZeroPageCoalesce.getThreadHeads(getProgram());
+      Collection<ScopeRef> threads = Pass4MemoryCoalesce.getThreadHeads(getProgram());
       boolean modified;
       do {
          modified = coalesce(liveRangeEquivalenceClassSet, threads, unknownFragments);
@@ -66,8 +66,8 @@ public class Pass4ZeroPageCoalesceCallGraph extends Pass2Base {
             if(isScopeOverlap(otherEC, allCallingScopes))
                continue;
             // No scope overlap - attempt to coalesce
-            Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate = new Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate(thisEC, otherEC, null);
+            Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate = new Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate(thisEC, otherEC, null);
-            if(Pass4ZeroPageCoalesce.attemptCoalesce(candidate, threadHeads, unknownFragments, getProgram())) {
+            if(Pass4MemoryCoalesce.attemptCoalesce(candidate, threadHeads, unknownFragments, getProgram())) {
                // Succesfully coalesced with already handled EC - move on to the next one!
                coalesced = true;
                modified = true;

src/main/java/dk/camelot64/kickc/passes/Pass4MemoryCoalesceExhaustive.java

@@ -10,20 +10,20 @@ import java.util.LinkedHashSet;
 import java.util.Set;
 
 /**
- * Exhaustive attempt to coalesces zero page registers where live ranges do not overlap.
+ * Exhaustive attempt to coalesces memory registers where live ranges do not overlap.
  * An optional final step done after all other register optimizations and before ASM generation.
  * Performs an exhaustive search - so it can take a lot of time!
  */
-public class Pass4ZeroPageCoalesceExhaustive extends Pass2Base {
+public class Pass4MemoryCoalesceExhaustive extends Pass2Base {
 
-   public Pass4ZeroPageCoalesceExhaustive(Program program) {
+   public Pass4MemoryCoalesceExhaustive(Program program) {
       super(program);
    }
 
    public void coalesce() {
       LinkedHashSet<String> unknownFragments = new LinkedHashSet<>();
       LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet = getProgram().getLiveRangeEquivalenceClassSet();
-      Collection<ScopeRef> threads = Pass4ZeroPageCoalesce.getThreadHeads(getProgram());
+      Collection<ScopeRef> threads = Pass4MemoryCoalesce.getThreadHeads(getProgram());
       boolean change;
       do {
          change = coalesce(liveRangeEquivalenceClassSet, threads, unknownFragments);
@@ -48,8 +48,8 @@ public class Pass4ZeroPageCoalesceExhaustive extends Pass2Base {
    private boolean coalesce(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet, Collection<ScopeRef> threadHeads, Set<String> unknownFragments) {
       for(LiveRangeEquivalenceClass thisEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
          for(LiveRangeEquivalenceClass otherEquivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
-            Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate = new Pass4ZeroPageCoalesce.LiveRangeEquivalenceClassCoalesceCandidate(thisEquivalenceClass, otherEquivalenceClass, null);
+            Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate candidate = new Pass4MemoryCoalesce.LiveRangeEquivalenceClassCoalesceCandidate(thisEquivalenceClass, otherEquivalenceClass, null);
-            boolean modified = Pass4ZeroPageCoalesce.attemptCoalesce(candidate, threadHeads, unknownFragments, getProgram());
+            boolean modified = Pass4MemoryCoalesce.attemptCoalesce(candidate, threadHeads, unknownFragments, getProgram());
             if(modified) {
                return true;
             }

src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java

@@ -77,7 +77,7 @@ public class Pass4RegistersFinalize extends Pass2Base {
 
       
       if(reallocateZp) {
-         reallocateZpRegisters(liveRangeEquivalenceClassSet);
+         reallocateMemRegisters(liveRangeEquivalenceClassSet);
       }
       liveRangeEquivalenceClassSet.storeRegisterAllocation();
       if(reallocateZp) {
@@ -160,11 +160,11 @@ public class Pass4RegistersFinalize extends Pass2Base {
    }
 
    /**
-    * Reallocate all ZP registers to minimize ZP usage
+    * Reallocate all memory registers. Minimizes zeropage usage.
     *
     * @param liveRangeEquivalenceClassSet The
     */
-   private void reallocateZpRegisters(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet) {
+   private void reallocateMemRegisters(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet) {
       for(LiveRangeEquivalenceClass equivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
          Registers.Register register = equivalenceClass.getRegister();
          boolean reallocate = true;

src/test/java/dk/camelot64/kickc/test/TestPrograms.java

@@ -3369,7 +3369,7 @@ public class TestPrograms {
       tester.testFile(filename, upliftCombinations, null);
    }
 
-   private void compileAndCompare(String filename, CompileLog log, int upliftCombinations) throws IOException, URISyntaxException {
+   private void compileAndCompare(String filename, int upliftCombinations, CompileLog log) throws IOException, URISyntaxException {
       TestPrograms tester = new TestPrograms();
       tester.testFile(filename, upliftCombinations, log);
    }