Improved zp register references across scopes.

src/main/java/dk/camelot64/kickc/asm/AsmFragment.java

@@ -23,12 +23,16 @@ public class AsmFragment {
     */
    private Map<String, Value> bindings;
 
+   /** The scope containing the fragment. Used when referenginv symbols defined in other scopes. */
+   private ScopeRef scope;
+
    /**
     * The string signature/name of the fragment fragment.
     */
    private String signature;
 
    public AsmFragment(StatementConditionalJump conditionalJump, ControlFlowBlock block, Program program, ControlFlowGraph graph) {
+      this.scope = program.getGraph().getBlockFromStatementIdx(conditionalJump.getIndex()).getScope();
       this.bindings = new LinkedHashMap<>();
       this.program = program;
       String conditionalJumpSignature = conditionalJumpSignature(conditionalJump, block, graph);
@@ -36,18 +40,21 @@ public class AsmFragment {
    }
 
    public AsmFragment(StatementAssignment assignment, Program program) {
+      this.scope = program.getGraph().getBlockFromStatementIdx(assignment.getIndex()).getScope();
       this.bindings = new LinkedHashMap<>();
       this.program = program;
       setSignature(assignmentSignature(assignment.getlValue(), assignment.getrValue1(), assignment.getOperator(), assignment.getrValue2()));
    }
 
-   public AsmFragment(LValue lValue, RValue rValue, Program program) {
+   public AsmFragment(LValue lValue, RValue rValue, Program program, Statement statement) {
+      this.scope = program.getGraph().getBlockFromStatementIdx(statement.getIndex()).getScope();
       this.bindings = new LinkedHashMap<>();
       this.program = program;
       setSignature(assignmentSignature(lValue, null, null, rValue));
    }
 
    public AsmFragment(StatementAssignment assignment, StatementAssignment assignmentAlu, Program program) {
+      this.scope = program.getGraph().getBlockFromStatementIdx(assignment.getIndex()).getScope();
       this.bindings = new LinkedHashMap<>();
       this.program = program;
       setSignature(assignmentWithAluSignature(assignment, assignmentAlu));
@@ -55,6 +62,7 @@ public class AsmFragment {
    }
 
    private String assignmentWithAluSignature(StatementAssignment assignment, StatementAssignment assignmentAlu) {
+      this.scope = program.getGraph().getBlockFromStatementIdx(assignment.getIndex()).getScope();
       if (!(assignment.getrValue2() instanceof VariableRef)) {
          throw new AluNotApplicableException("Error! ALU register only allowed as rValue2. " + assignment);
       }
@@ -301,14 +309,19 @@ public class AsmFragment {
       String bound;
       if (boundValue instanceof Registers.Register) {
          Registers.Register register = (Registers.Register) boundValue;
-         if (register instanceof Registers.RegisterZpByte) {
-            bound = String.format("$%x", ((Registers.RegisterZpByte) register).getZp());
-         } else if (register instanceof Registers.RegisterZpWord) {
-            bound = String.format("$%x", ((Registers.RegisterZpWord) register).getZp());
-         } else if (register instanceof Registers.RegisterZpBool) {
-            bound = String.format("$%x", ((Registers.RegisterZpBool) register).getZp());
-         } else if (register instanceof Registers.RegisterZpPointerByte) {
-            bound = String.format("$%x", ((Registers.RegisterZpPointerByte) register).getZp());
+         if (register instanceof Registers.RegisterZp) {
+            Registers.RegisterZp zpReg = (Registers.RegisterZp) register;
+            if(zpReg.getName()!=null) {
+               Variable variable = zpReg.getVariable();
+               Scope varScope = variable.getScope();
+               if(!varScope.getRef().equals(scope) && varScope.getRef().getFullName().length()>0) {
+                  bound = varScope.getFullName()+"."+zpReg.getName().replace('@', 'b').replace(':', '_').replace("#", "_");
+               }  else {
+                  bound = zpReg.getName().replace('@', 'b').replace(':', '_').replace("#", "_");
+               }
+            }  else {
+               bound = String.format("$%x", zpReg.getZp());
+            }
          } else {
             throw new RuntimeException("Register Type not implemented " + register);
          }

src/main/java/dk/camelot64/kickc/asm/AsmLabelDecl.java

@@ -0,0 +1,39 @@
+package dk.camelot64.kickc.asm;
+
+/** A label declaration .label lbl = val  */
+public class AsmLabelDecl implements AsmLine {
+   private final String name;
+   private final int address;
+   private int index;
+
+
+   public AsmLabelDecl(String name, int address) {
+      this.name = name;
+      this.address = address;
+   }
+
+   @Override
+   public int getLineBytes() {
+      return 0;
+   }
+
+   @Override
+   public double getLineCycles() {
+      return 0;
+   }
+
+   @Override
+   public String getAsm() {
+      return ".label "+name+" = "+address;
+   }
+
+   @Override
+   public int getIndex() {
+      return index;
+   }
+
+   @Override
+   public void setIndex(int index) {
+      this.index = index;
+   }
+}

src/main/java/dk/camelot64/kickc/asm/AsmProgram.java

@@ -72,6 +72,12 @@ public class AsmProgram {
       addLine(new AsmInstruction(instructionType, parameter));
    }
 
+   public void addLabelDecl(String name, int address) {
+      addLine(new AsmLabelDecl(name, address));
+
+   }
+
+
 
    /**
     * Get the number of bytes the segment occupies in memory.

src/main/java/dk/camelot64/kickc/asm/AsmSegment.java

@@ -138,7 +138,7 @@ public class AsmSegment {
             printState.decIndent();
          }
          out.append(printState.getIndent());
-         if (line instanceof AsmComment || line instanceof AsmInstruction ) {
+         if (line instanceof AsmComment || line instanceof AsmInstruction || line instanceof AsmLabelDecl) {
             out.append("  ");
          }
          out.append(line.getAsm() + "\n");

src/main/java/dk/camelot64/kickc/icl/Registers.java

@@ -34,8 +34,7 @@ public class Registers {
 
    }
 
-   /** A zero page address used as a register for a single byte variable. */
-   public static class RegisterZpByte implements Register {
+   public static abstract class RegisterZp implements Register {
 
       /** The ZP address used for the byte. */
       private int zp;
@@ -43,60 +42,84 @@ public class Registers {
       /** The name used as a label for the register in the ASM code. */
       private String name;
 
-      public RegisterZpByte(int zp) {
+      /** The variable represented by the register. */
+      private Variable variable;
+
+      public RegisterZp(int zp, String name, Variable variable) {
          this.zp = zp;
+         this.name = name;
+         this.variable = variable;
       }
 
       public int getZp() {
          return zp;
       }
 
+      public String getName() {
+         return name;
+      }
+
+      public Variable getVariable() {
+         return variable;
+      }
+
+      @Override
+      public boolean isZp() {
+         return true;
+      }
+
+      @Override
+      public String toString() {
+         return "zp "+getType().toString()+":"+zp+(name==null?"":(" "+name));
+      }
+
+      @Override
+      public String toString(Program program) {
+         return toString();
+      }
+
+      @Override
+      public boolean equals(Object o) {
+         if (this == o) return true;
+         if (o == null || getClass() != o.getClass()) return false;
+         RegisterZp that = (RegisterZp) o;
+         if (zp != that.zp) return false;
+         return name != null ? name.equals(that.name) : that.name == null;
+      }
+
+      @Override
+      public int hashCode() {
+         int result = zp;
+         result = 31 * result + (name != null ? name.hashCode() : 0);
+         return result;
+      }
+
+      public void setName(String name) {
+         this.name = name;
+      }
+   }
+
+
+   /** A zero page address used as a register for a single byte variable. */
+   public static class RegisterZpByte extends RegisterZp {
+
+      public RegisterZpByte(int zp, String name, Variable variable) {
+         super(zp, name, variable);
+      }
+
       @Override
       public RegisterType getType() {
          return  RegisterType.ZP_BYTE;
       }
 
-      @Override
-      public boolean isZp() {
-         return true;
-      }
-
-      @Override
-      public String toString() {
-         return "zp byte:"+zp;
-      }
-
-      @Override
-      public boolean equals(Object o) {
-         if (this == o) return true;
-         if (o == null || getClass() != o.getClass()) return false;
-         RegisterZpByte that = (RegisterZpByte) o;
-         return zp == that.zp;
-      }
-
-      @Override
-      public int hashCode() {
-         return zp;
-      }
-
-      @Override
-      public String toString(Program program) {
-         return toString();
-      }
 
    }
 
    /** Two zero page addresses used as a register for a single word variable. */
-   public static class RegisterZpWord implements Register {
+   public static class RegisterZpWord extends  RegisterZp {
 
-      private int zp;
-
-      public RegisterZpWord(int zp) {
-         this.zp = zp;
-      }
-
-      public int getZp() {
-         return zp;
+      public RegisterZpWord(int zp, String name, Variable variable) {
+         super(zp, name, variable);
       }
 
       @Override
@@ -104,46 +127,13 @@ public class Registers {
          return  RegisterType.ZP_WORD;
       }
 
-      @Override
-      public boolean isZp() {
-         return true;
-      }
-
-      @Override
-      public String toString() {
-         return "zp word :"+zp;
-      }
-
-      @Override
-      public boolean equals(Object o) {
-         if (this == o) return true;
-         if (o == null || getClass() != o.getClass()) return false;
-         RegisterZpWord that = (RegisterZpWord) o;
-         return zp == that.zp;
-      }
-
-      @Override
-      public int hashCode() {
-         return zp;
-      }
-
-      @Override
-      public String toString(Program program) {
-         return toString();
-      }
-
    }
 
    /** A zero page address used as a register for a boolean variable. */
-   public static class RegisterZpBool implements Register {
-      private int zp;
+   public static class RegisterZpBool extends  RegisterZp {
 
-      public RegisterZpBool(int zp) {
-         this.zp = zp;
-      }
-
-      public int getZp() {
-         return zp;
+      public RegisterZpBool(int zp, String name, Variable variable) {
+         super(zp, name, variable);
       }
 
       @Override
@@ -151,42 +141,14 @@ public class Registers {
          return  RegisterType.ZP_BOOL;
       }
 
-      @Override
-      public boolean isZp() {
-         return true;
-      }
-
-      @Override
-      public String toString() {
-         return "zp bool:"+zp;
-      }
-
-      @Override
-      public boolean equals(Object o) {
-         if (this == o) return true;
-         if (o == null || getClass() != o.getClass()) return false;
-         RegisterZpBool that = (RegisterZpBool) o;
-         return zp == that.zp;
-      }
-
-      @Override
-      public int hashCode() {
-         return zp;
-      }
-
-      @Override
-      public String toString(Program program) {
-         return toString();
-      }
 
    }
 
    /** A zro page address pair used as a register containing a pointer to a byte. */
-   public static class RegisterZpPointerByte implements Register {
-      private int zp;
+   public static class RegisterZpPointerByte extends  RegisterZp {
 
-      public RegisterZpPointerByte(int zp) {
-         this.zp = zp;
+      public RegisterZpPointerByte(int zp, String name, Variable variable) {
+         super(zp, name, variable);
       }
 
       @Override
@@ -194,40 +156,10 @@ public class Registers {
          return RegisterType.ZP_PTR_BYTE;
       }
 
-      @Override
-      public boolean isZp() {
-         return true;
-      }
-
-      @Override
-      public String toString() {
-         return "zp ptr byte:"+zp;
-      }
-
-      @Override
-      public boolean equals(Object o) {
-         if (this == o) return true;
-         if (o == null || getClass() != o.getClass()) return false;
-         RegisterZpPointerByte that = (RegisterZpPointerByte) o;
-         return zp == that.zp;
-      }
-
-      @Override
-      public int hashCode() {
-         return zp;
-      }
-
-      public int getZp() {
-         return zp;
-      }
-
-      @Override
-      public String toString(Program program) {
-         return toString();
-      }
-
    }
 
+
+
    /** The X register. */
    public static class RegisterXByte implements Register {
       @Override

src/main/java/dk/camelot64/kickc/icl/Scope.java

@@ -241,6 +241,10 @@ public abstract class Scope implements Symbol {
    }
 
    public Scope getScope(ScopeRef scopeRef) {
+      if(scopeRef.getFullName().equals("") && this instanceof ProgramScope) {
+         // Special case for the outer program scope
+         return this;
+      }
       Symbol symbol = getSymbol(scopeRef);
       if(symbol instanceof Scope) {
          return (Scope) symbol;

src/main/java/dk/camelot64/kickc/icl/Variable.java

@@ -18,7 +18,7 @@ public abstract class Variable implements Symbol {
    /** true if the symbol type is infered (not declared) */
    private boolean inferredType;
 
-   /** If the variable is assigned to an ASM register, this contains the register. If null the variable has no no allocation (yet). Constants are never assigned to registers. */
+   /** If the variable is assigned to an ASM register, this contains the register. If null the variable has no allocation (yet). Constants are never assigned to registers. */
    private Registers.Register allocation;
 
    /** If the variable is a constant this is the constant value. If null the variable is not considered constant.*/

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

@@ -28,6 +28,10 @@ public class Pass4CodeGeneration {
    public void generate() {
       AsmProgram asm = new AsmProgram();
       ScopeRef currentScope = ScopeRef.ROOT;
+
+      // Generate global ZP labels
+      asm.startSegment(null, "Global ZP labels");
+      addZpLabels(asm, currentScope);
       for (ControlFlowBlock block : getGraph().getAllBlocks()) {
          if (!block.getScope().equals(currentScope)) {
             if (!ScopeRef.ROOT.equals(currentScope)) {
@@ -36,6 +40,8 @@ public class Pass4CodeGeneration {
             currentScope = block.getScope();
             asm.startSegment(null, block.getLabel().getFullName());
             asm.addScopeBegin(block.getLabel().getFullName().replace('@', 'b').replace(':', '_'));
+            // Add all ZP labels for the scope
+            addZpLabels(asm, currentScope);
          }
          // Generate entry points (if needed)
          genBlockEntryPoints(asm, block);
@@ -61,6 +67,27 @@ public class Pass4CodeGeneration {
       program.setAsm(asm);
    }
 
+   /**
+    * Add label declarations for all scope variables assigned to ZP registers
+    * @param asm The ASM program
+    * @param scope The scope
+    */
+   private void addZpLabels(AsmProgram asm, ScopeRef scope) {
+      Collection<Variable> scopeVars = program.getScope().getScope(scope).getAllVariables(false);
+      Set<String> added = new LinkedHashSet<>();
+      for (Variable scopeVar : scopeVars) {
+         Registers.Register register = scopeVar.getAllocation();
+         if(register!=null && register.isZp()) {
+            Registers.RegisterZp registerZp = (Registers.RegisterZp) register;
+            String registerZpName = registerZp.getName();
+            if(registerZpName !=null && !added.contains(registerZpName)) {
+               asm.addLabelDecl(registerZpName, registerZp.getZp());
+               added.add(registerZpName);
+            }
+         }
+      }
+   }
+
    private void genStatements(AsmProgram asm, ControlFlowBlock block) {
       Iterator<Statement> statementsIt = block.getStatements().iterator();
       AsmCodegenAluState aluState = new AsmCodegenAluState();
@@ -228,7 +255,7 @@ public class Pass4CodeGeneration {
       if (isRegisterCopy(lValue, rValue)) {
          asm.getCurrentSegment().setFragment("register_copy");
       } else {
-         AsmFragment asmFragment = new AsmFragment(lValue, rValue, program);
+         AsmFragment asmFragment = new AsmFragment(lValue, rValue, program, statement);
          asm.getCurrentSegment().setFragment(asmFragment.getSignature());
          asmFragment.generate(asm);
       }

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

@@ -2,9 +2,13 @@ package dk.camelot64.kickc.passes;
 
 import dk.camelot64.kickc.icl.*;
 
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
 /**
  * Move register allocation from equivalence classes to RegisterAllocation.
- * Also rebase zero page registers.
+ * Also reallocate and rename zero page registers in the equivalence classes.
  */
 public class Pass4RegistersFinalize extends Pass2Base {
 
@@ -12,12 +16,54 @@ public class Pass4RegistersFinalize extends Pass2Base {
       super(program);
    }
 
-   public void allocate(boolean reallocZp) {
+   public void allocate(boolean reallocateZp) {
       LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet = getProgram().getLiveRangeEquivalenceClassSet();
-      if(reallocZp) {
-         reallocateZp(liveRangeEquivalenceClassSet);
+      if (reallocateZp) {
+         reallocateZpRegisters(liveRangeEquivalenceClassSet);
       }
       liveRangeEquivalenceClassSet.storeRegisterAllocation();
+      if (reallocateZp) {
+         shortenZpRegisterNames(liveRangeEquivalenceClassSet);
+      }
+   }
+
+   /**
+    * Shorten register names for ZP registers if possible
+    *
+    * @param equivalenceClassSet
+    */
+   private void shortenZpRegisterNames(LiveRangeEquivalenceClassSet equivalenceClassSet) {
+      Collection<Scope> allScopes = getProgram().getScope().getAllScopes(true);
+      allScopes.add(getProgram().getScope());
+      for (Scope scope : allScopes) {
+         Set<String> used = new LinkedHashSet<>();
+         // Find all names without "#"
+         for (Variable variable : scope.getAllVariables(false)) {
+            if (variable.getAllocation() != null && variable.getAllocation().isZp()) {
+               Registers.RegisterZp regZp = (Registers.RegisterZp) variable.getAllocation();
+               String regZpName = regZp.getName();
+               if (!regZpName.contains("#")) {
+                  used.add(regZpName);
+               }
+            }
+         }
+
+         // For all names with "#" try to shorten
+         for (Variable variable : scope.getAllVariables(false)) {
+            if (variable.getAllocation() != null && variable.getAllocation().isZp()) {
+               Registers.RegisterZp regZp = (Registers.RegisterZp) variable.getAllocation();
+               String regZpName = regZp.getName();
+               if (regZpName.contains("#")) {
+                  regZpName = regZpName.substring(0, regZpName.indexOf("#"));
+                  if (!used.contains(regZpName)) {
+                     regZp.setName(regZpName);
+                     used.add(regZpName);
+                  }
+               }
+            }
+         }
+
+      }
    }
 
    /**
@@ -25,17 +71,17 @@ public class Pass4RegistersFinalize extends Pass2Base {
     *
     * @param liveRangeEquivalenceClassSet The
     */
-   private void reallocateZp(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet) {
+   private void reallocateZpRegisters(LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet) {
       for (LiveRangeEquivalenceClass equivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
          Registers.Register register = equivalenceClass.getRegister();
-         if(register==null || register.isZp()) {
-            String before = register==null?null:register.toString();
-            VariableRef variable = equivalenceClass.getVariables().get(0);
-            Variable symbol = getProgram().getScope().getVariable(variable);
-            register = allocateNewRegisterZp(symbol.getType());
+         if (register == null || register.isZp()) {
+            String before = register == null ? null : register.toString();
+            VariableRef variableRef = equivalenceClass.getVariables().get(0);
+            Variable variable = getProgram().getScope().getVariable(variableRef);
+            register = allocateNewRegisterZp(variable);
             equivalenceClass.setRegister(register);
-            if(before==null || !before.equals(register.toString())) {
-               getLog().append("Allocated " + (before==null?"":("(was "+before+") ")) + equivalenceClass.toString());
+            if (before == null || !before.equals(register.toString())) {
+               getLog().append("Allocated " + (before == null ? "" : ("(was " + before + ") ")) + equivalenceClass.toString());
             }
          }
       }
@@ -53,22 +99,24 @@ public class Pass4RegistersFinalize extends Pass2Base {
     *                The register type created uses one or more zero page locations based on the variable type
     * @return The new zeropage register
     */
-   private Registers.Register allocateNewRegisterZp(SymbolType varType) {
+   private Registers.Register allocateNewRegisterZp(Variable variable) {
+      SymbolType varType = variable.getType();
+      String name = variable.getLocalName();
       if (varType.equals(SymbolTypeBasic.BYTE)) {
-         return new Registers.RegisterZpByte(currentZp++);
+         return new Registers.RegisterZpByte(currentZp++, name, variable);
       } else if (varType.equals(SymbolTypeBasic.WORD)) {
          Registers.RegisterZpWord registerZpWord =
-               new Registers.RegisterZpWord(currentZp);
+               new Registers.RegisterZpWord(currentZp, name, variable);
          currentZp = currentZp + 2;
          return registerZpWord;
       } else if (varType.equals(SymbolTypeBasic.BOOLEAN)) {
-         return new Registers.RegisterZpBool(currentZp++);
+         return new Registers.RegisterZpBool(currentZp++, name, variable);
       } else if (varType.equals(SymbolTypeBasic.VOID)) {
          // No need to setRegister register for VOID value
          return null;
       } else if (varType instanceof SymbolTypePointer) {
          Registers.RegisterZpPointerByte registerZpPointerByte =
-               new Registers.RegisterZpPointerByte(currentZp);
+               new Registers.RegisterZpPointerByte(currentZp, name, variable);
          currentZp = currentZp + 2;
          return registerZpPointerByte;
       } else {
@@ -77,5 +125,4 @@ public class Pass4RegistersFinalize extends Pass2Base {
    }
 
 
-
 }

src/main/java/dk/camelot64/kickc/test/TestCompilationOutput.java

@@ -24,6 +24,10 @@ public class TestCompilationOutput extends TestCase {
       helper = new ReferenceHelper("dk/camelot64/kickc/test/ref/");
    }
 
+   public void testZpParamMin() throws IOException, URISyntaxException {
+      compileAndCompare("zpparammin");
+   }
+
    public void testInMemArray() throws IOException, URISyntaxException {
       compileAndCompare("inmemarray");
    }

src/main/java/dk/camelot64/kickc/test/modglobal.kc

@@ -1,5 +1,6 @@
 byte cnt = 0;
 byte cnt2 = 0;
+byte cnt3 = 0;
 byte[256] SCREEN=$0400;
 
 main();
@@ -13,6 +14,7 @@ void main() {
 byte inccnt() {
     ++cnt;
     ++cnt2;
+    ++cnt3;
     return cnt;
 }
 

src/main/java/dk/camelot64/kickc/test/ref/bresenham.asm

@@ -1,22 +1,25 @@
   jsr main
 main: {
+    .label x = 4
+    .label cursor = 2
+    .label y = 5
     lda #$0
-    sta $5
+    sta y
     ldx #$c
     lda #$0
-    sta $4
+    sta x
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
+    sta cursor+$1
   b1:
     ldy #$0
     lda #$51
-    sta ($2),y
-    inc $4
-    inc $2
+    sta (cursor),y
+    inc x
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
     txa
     clc
@@ -24,20 +27,20 @@ main: {
     tax
     cpx #$27
     bcc b2
-    inc $5
-    lda $2
+    inc y
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
     txa
     sec
     sbc #$27
     tax
   b2:
-    lda $4
+    lda x
     cmp #$28
     bcc b1
     rts

src/main/java/dk/camelot64/kickc/test/ref/bresenham.log

@@ -1502,116 +1502,121 @@ Complete equivalence classes
 [ main::x#2 main::x#1 ]
 [ main::e#3 main::e#5 main::e#1 main::e#2 ]
 [ main::y#2 main::y#4 main::y#1 ]
-Allocated zp ptr byte:2 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
-Allocated zp byte:4 [ main::x#2 main::x#1 ]
-Allocated zp byte:5 [ main::e#3 main::e#5 main::e#1 main::e#2 ]
-Allocated zp byte:6 [ main::y#2 main::y#4 main::y#1 ]
+Allocated zp ZP_PTR_BYTE:2 cursor#3 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
+Allocated zp ZP_BYTE:4 x#2 [ main::x#2 main::x#1 ]
+Allocated zp ZP_BYTE:5 e#3 [ main::e#3 main::e#5 main::e#1 main::e#2 ]
+Allocated zp ZP_BYTE:6 y#2 [ main::y#2 main::y#4 main::y#1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label x = 4
+    .label cursor = 2
+    .label e = 5
+    .label y = 6
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $6
-  //SEG6 [1] phi (byte) main::e#3 = (byte) 12 -- zpby1=coby1 
+    sta y
+  //SEG7 [1] phi (byte) main::e#3 = (byte) 12 -- zpby1=coby1 
     lda #$c
-    sta $5
-  //SEG7 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
+    sta e
+  //SEG8 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $4
-  //SEG8 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
+    sta x
+  //SEG9 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
+    sta cursor+$1
     jmp b1
-  //SEG9 [1] phi from main::@2 to main::@1
+  //SEG10 [1] phi from main::@2 to main::@1
   b1_from_b2:
-  //SEG10 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG11 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG12 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG13 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG11 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
+  //SEG12 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
+  //SEG13 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
+  //SEG14 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
     jmp b1
-  //SEG14 main::@1
+  //SEG15 main::@1
   b1:
-  //SEG15 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
+  //SEG16 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
     ldy #$0
     lda #$51
-    sta ($2),y
-  //SEG16 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
-    inc $4
-  //SEG17 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
-    inc $2
+    sta (cursor),y
+  //SEG17 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
+    inc x
+  //SEG18 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG18 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- zpby1=zpby1_plus_coby1 
-    lda $5
+  //SEG19 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- zpby1=zpby1_plus_coby1 
+    lda e
     clc
     adc #$18
-    sta $5
-  //SEG19 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_zpby1_then_la1 
+    sta e
+  //SEG20 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_zpby1_then_la1 
     lda #$27
-    cmp $5
+    cmp e
     bcs b2_from_b1
     jmp b3
-  //SEG20 main::@3
+  //SEG21 main::@3
   b3:
-  //SEG21 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
-    inc $6
-  //SEG22 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
-    lda $2
+  //SEG22 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
+    inc y
+  //SEG23 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG23 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- zpby1=zpby1_minus_coby1 
-    lda $5
+  //SEG24 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- zpby1=zpby1_minus_coby1 
+    lda e
     sec
     sbc #$27
-    sta $5
-  //SEG24 [10] phi from main::@3 to main::@2
+    sta e
+  //SEG25 [10] phi from main::@3 to main::@2
   b2_from_b3:
-  //SEG25 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
-  //SEG26 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
-  //SEG27 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
+  //SEG26 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
+  //SEG27 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
+  //SEG28 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
     jmp b2
-  //SEG28 [10] phi from main::@1 to main::@2
+  //SEG29 [10] phi from main::@1 to main::@2
   b2_from_b1:
-  //SEG29 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG30 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG31 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG30 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
+  //SEG31 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
+  //SEG32 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
     jmp b2
-  //SEG32 main::@2
+  //SEG33 main::@2
   b2:
-  //SEG33 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
-    lda $4
+  //SEG34 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
+    lda x
     cmp #$28
     bcc b1_from_b2
     jmp breturn
-  //SEG34 main::@return
+  //SEG35 main::@return
   breturn:
-  //SEG35 [12] return  [ ]
+  //SEG36 [12] return  [ ]
     rts
 }
 
 Statement [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] always clobbers reg byte a reg byte y 
-Removing always clobbered register reg byte a as potential for zp byte:4 [ main::x#2 main::x#1 ]
-Removing always clobbered register reg byte y as potential for zp byte:4 [ main::x#2 main::x#1 ]
-Removing always clobbered register reg byte a as potential for zp byte:5 [ main::e#3 main::e#5 main::e#1 main::e#2 ]
-Removing always clobbered register reg byte y as potential for zp byte:5 [ main::e#3 main::e#5 main::e#1 main::e#2 ]
-Removing always clobbered register reg byte a as potential for zp byte:6 [ main::y#2 main::y#4 main::y#1 ]
-Removing always clobbered register reg byte y as potential for zp byte:6 [ main::y#2 main::y#4 main::y#1 ]
+Removing always clobbered register reg byte a as potential for zp ZP_BYTE:4 x [ main::x#2 main::x#1 ]
+Removing always clobbered register reg byte y as potential for zp ZP_BYTE:4 x [ main::x#2 main::x#1 ]
+Removing always clobbered register reg byte a as potential for zp ZP_BYTE:5 e [ main::e#3 main::e#5 main::e#1 main::e#2 ]
+Removing always clobbered register reg byte y as potential for zp ZP_BYTE:5 e [ main::e#3 main::e#5 main::e#1 main::e#2 ]
+Removing always clobbered register reg byte a as potential for zp ZP_BYTE:6 y [ main::y#2 main::y#4 main::y#1 ]
+Removing always clobbered register reg byte y as potential for zp ZP_BYTE:6 y [ main::y#2 main::y#4 main::y#1 ]
 Statement [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] always clobbers reg byte a 
 Statement [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] always clobbers reg byte a 
 Statement [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] always clobbers reg byte a 
@@ -1620,18 +1625,20 @@ Statement [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main
 Statement [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] always clobbers reg byte a 
 Statement [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] always clobbers reg byte a 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp ptr byte:2 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ] : zp ptr byte:2 , 
-Potential registers zp byte:4 [ main::x#2 main::x#1 ] : zp byte:4 , reg byte x , 
-Potential registers zp byte:5 [ main::e#3 main::e#5 main::e#1 main::e#2 ] : zp byte:5 , reg byte x , 
-Potential registers zp byte:6 [ main::y#2 main::y#4 main::y#1 ] : zp byte:6 , reg byte x , 
+Potential registers zp ZP_PTR_BYTE:2 cursor [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ] : zp ZP_PTR_BYTE:2 cursor , 
+Potential registers zp ZP_BYTE:4 x [ main::x#2 main::x#1 ] : zp ZP_BYTE:4 x , reg byte x , 
+Potential registers zp ZP_BYTE:5 e [ main::e#3 main::e#5 main::e#1 main::e#2 ] : zp ZP_BYTE:5 e , reg byte x , 
+Potential registers zp ZP_BYTE:6 y [ main::y#2 main::y#4 main::y#1 ] : zp ZP_BYTE:6 y , reg byte x , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 55: zp byte:5 [ main::e#3 main::e#5 main::e#1 main::e#2 ] 46.75: zp ptr byte:2 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ] 29.33: zp byte:6 [ main::y#2 main::y#4 main::y#1 ] 14.67: zp byte:4 [ main::x#2 main::x#1 ] 
+Uplift Scope [main] 55: zp ZP_BYTE:5 e [ main::e#3 main::e#5 main::e#1 main::e#2 ] 46.75: zp ZP_PTR_BYTE:2 cursor [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ] 29.33: zp ZP_BYTE:6 y [ main::y#2 main::y#4 main::y#1 ] 14.67: zp ZP_BYTE:4 x [ main::x#2 main::x#1 ] 
 Uplift Scope [] 
 
-Uplifting [main] best 1225 combination reg byte x [ main::e#3 main::e#5 main::e#1 main::e#2 ] zp ptr byte:2 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ] zp byte:6 [ main::y#2 main::y#4 main::y#1 ] zp byte:4 [ main::x#2 main::x#1 ] 
-Uplifting [] best 1225 combination 
-Allocated (was zp byte:6) zp byte:5 [ main::y#2 main::y#4 main::y#1 ]
+Uplifting [main] best 1315 combination reg byte x [ main::e#3 main::e#5 main::e#1 main::e#2 ] zp ZP_PTR_BYTE:2 cursor [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ] zp ZP_BYTE:6 y [ main::y#2 main::y#4 main::y#1 ] zp ZP_BYTE:4 x [ main::x#2 main::x#1 ] 
+Uplifting [] best 1315 combination 
+Allocated (was zp ZP_PTR_BYTE:2 cursor) zp ZP_PTR_BYTE:2 cursor#3 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
+Allocated (was zp ZP_BYTE:4 x) zp ZP_BYTE:4 x#2 [ main::x#2 main::x#1 ]
+Allocated (was zp ZP_BYTE:6 y) zp ZP_BYTE:5 y#2 [ main::y#2 main::y#4 main::y#1 ]
 Removing instruction jmp bend
 Removing instruction jmp b1
 Removing instruction jmp b3
@@ -1639,94 +1646,98 @@ Removing instruction jmp b2
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label x = 4
+    .label cursor = 2
+    .label y = 5
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $5
-  //SEG6 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
+    sta y
+  //SEG7 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
     ldx #$c
-  //SEG7 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $4
-  //SEG8 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
+    sta x
+  //SEG9 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
+    sta cursor+$1
     jmp b1
-  //SEG9 [1] phi from main::@2 to main::@1
+  //SEG10 [1] phi from main::@2 to main::@1
   b1_from_b2:
-  //SEG10 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG11 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG12 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG13 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
-  //SEG14 main::@1
+  //SEG11 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
+  //SEG12 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
+  //SEG13 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
+  //SEG14 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG15 main::@1
   b1:
-  //SEG15 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
+  //SEG16 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
     ldy #$0
     lda #$51
-    sta ($2),y
-  //SEG16 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
-    inc $4
-  //SEG17 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
-    inc $2
+    sta (cursor),y
+  //SEG17 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
+    inc x
+  //SEG18 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG18 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
+  //SEG19 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
     txa
     clc
     adc #$18
     tax
-  //SEG19 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
+  //SEG20 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
     cpx #$27
     bcc b2_from_b1
-  //SEG20 main::@3
+  //SEG21 main::@3
   b3:
-  //SEG21 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
-    inc $5
-  //SEG22 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
-    lda $2
+  //SEG22 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
+    inc y
+  //SEG23 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG23 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
+  //SEG24 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
     txa
     sec
     sbc #$27
     tax
-  //SEG24 [10] phi from main::@3 to main::@2
+  //SEG25 [10] phi from main::@3 to main::@2
   b2_from_b3:
-  //SEG25 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
-  //SEG26 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
-  //SEG27 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
+  //SEG26 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
+  //SEG27 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
+  //SEG28 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
     jmp b2
-  //SEG28 [10] phi from main::@1 to main::@2
+  //SEG29 [10] phi from main::@1 to main::@2
   b2_from_b1:
-  //SEG29 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG30 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG31 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
-  //SEG32 main::@2
+  //SEG30 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
+  //SEG31 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
+  //SEG32 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG33 main::@2
   b2:
-  //SEG33 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
-    lda $4
+  //SEG34 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
+    lda x
     cmp #$28
     bcc b1_from_b2
-  //SEG34 main::@return
+  //SEG35 main::@return
   breturn:
-  //SEG35 [12] return  [ ]
+  //SEG36 [12] return  [ ]
     rts
 }
 
@@ -1736,92 +1747,96 @@ Removing instruction b1_from_b2:
 Removing instruction b2_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label x = 4
+    .label cursor = 2
+    .label y = 5
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $5
-  //SEG6 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
+    sta y
+  //SEG7 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
     ldx #$c
-  //SEG7 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $4
-  //SEG8 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
+    sta x
+  //SEG9 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
+    sta cursor+$1
     jmp b1
-  //SEG9 [1] phi from main::@2 to main::@1
-  //SEG10 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG11 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG12 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG13 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
-  //SEG14 main::@1
+  //SEG10 [1] phi from main::@2 to main::@1
+  //SEG11 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
+  //SEG12 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
+  //SEG13 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
+  //SEG14 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG15 main::@1
   b1:
-  //SEG15 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
+  //SEG16 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
     ldy #$0
     lda #$51
-    sta ($2),y
-  //SEG16 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
-    inc $4
-  //SEG17 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
-    inc $2
+    sta (cursor),y
+  //SEG17 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
+    inc x
+  //SEG18 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG18 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
+  //SEG19 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
     txa
     clc
     adc #$18
     tax
-  //SEG19 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
+  //SEG20 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
     cpx #$27
     bcc b2
-  //SEG20 main::@3
+  //SEG21 main::@3
   b3:
-  //SEG21 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
-    inc $5
-  //SEG22 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
-    lda $2
+  //SEG22 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
+    inc y
+  //SEG23 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG23 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
+  //SEG24 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
     txa
     sec
     sbc #$27
     tax
-  //SEG24 [10] phi from main::@3 to main::@2
+  //SEG25 [10] phi from main::@3 to main::@2
   b2_from_b3:
-  //SEG25 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
-  //SEG26 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
-  //SEG27 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
+  //SEG26 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
+  //SEG27 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
+  //SEG28 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
     jmp b2
-  //SEG28 [10] phi from main::@1 to main::@2
-  //SEG29 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG30 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG31 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
-  //SEG32 main::@2
+  //SEG29 [10] phi from main::@1 to main::@2
+  //SEG30 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
+  //SEG31 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
+  //SEG32 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG33 main::@2
   b2:
-  //SEG33 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
-    lda $4
+  //SEG34 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
+    lda x
     cmp #$28
     bcc b1
-  //SEG34 main::@return
+  //SEG35 main::@return
   breturn:
-  //SEG35 [12] return  [ ]
+  //SEG36 [12] return  [ ]
     rts
 }
 
@@ -1833,86 +1848,90 @@ Removing instruction b2_from_b3:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
+    .label x = 4
+    .label cursor = 2
+    .label y = 5
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $5
-  //SEG6 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
+    sta y
+  //SEG7 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
     ldx #$c
-  //SEG7 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $4
-  //SEG8 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
+    sta x
+  //SEG9 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
+    sta cursor+$1
     jmp b1
-  //SEG9 [1] phi from main::@2 to main::@1
-  //SEG10 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG11 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG12 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG13 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
-  //SEG14 main::@1
+  //SEG10 [1] phi from main::@2 to main::@1
+  //SEG11 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
+  //SEG12 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
+  //SEG13 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
+  //SEG14 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG15 main::@1
   b1:
-  //SEG15 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
+  //SEG16 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
     ldy #$0
     lda #$51
-    sta ($2),y
-  //SEG16 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
-    inc $4
-  //SEG17 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
-    inc $2
+    sta (cursor),y
+  //SEG17 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
+    inc x
+  //SEG18 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG18 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
+  //SEG19 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
     txa
     clc
     adc #$18
     tax
-  //SEG19 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
+  //SEG20 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
     cpx #$27
     bcc b2
-  //SEG20 main::@3
-  //SEG21 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
-    inc $5
-  //SEG22 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
-    lda $2
+  //SEG21 main::@3
+  //SEG22 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
+    inc y
+  //SEG23 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG23 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
+  //SEG24 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
     txa
     sec
     sbc #$27
     tax
-  //SEG24 [10] phi from main::@3 to main::@2
-  //SEG25 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
-  //SEG26 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
-  //SEG27 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
+  //SEG25 [10] phi from main::@3 to main::@2
+  //SEG26 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
+  //SEG27 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
+  //SEG28 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
     jmp b2
-  //SEG28 [10] phi from main::@1 to main::@2
-  //SEG29 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG30 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG31 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
-  //SEG32 main::@2
+  //SEG29 [10] phi from main::@1 to main::@2
+  //SEG30 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
+  //SEG31 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
+  //SEG32 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG33 main::@2
   b2:
-  //SEG33 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
-    lda $4
+  //SEG34 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
+    lda x
     cmp #$28
     bcc b1
-  //SEG34 main::@return
-  //SEG35 [12] return  [ ]
+  //SEG35 main::@return
+  //SEG36 [12] return  [ ]
     rts
 }
 
@@ -1920,84 +1939,88 @@ Removing instruction jmp b1
 Removing instruction jmp b2
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
+    .label x = 4
+    .label cursor = 2
+    .label y = 5
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $5
-  //SEG6 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
+    sta y
+  //SEG7 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
     ldx #$c
-  //SEG7 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $4
-  //SEG8 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
+    sta x
+  //SEG9 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
-  //SEG9 [1] phi from main::@2 to main::@1
-  //SEG10 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG11 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG12 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG13 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
-  //SEG14 main::@1
+    sta cursor+$1
+  //SEG10 [1] phi from main::@2 to main::@1
+  //SEG11 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
+  //SEG12 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
+  //SEG13 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
+  //SEG14 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG15 main::@1
   b1:
-  //SEG15 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
+  //SEG16 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
     ldy #$0
     lda #$51
-    sta ($2),y
-  //SEG16 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
-    inc $4
-  //SEG17 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
-    inc $2
+    sta (cursor),y
+  //SEG17 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
+    inc x
+  //SEG18 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG18 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
+  //SEG19 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
     txa
     clc
     adc #$18
     tax
-  //SEG19 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
+  //SEG20 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
     cpx #$27
     bcc b2
-  //SEG20 main::@3
-  //SEG21 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
-    inc $5
-  //SEG22 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
-    lda $2
+  //SEG21 main::@3
+  //SEG22 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
+    inc y
+  //SEG23 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG23 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
+  //SEG24 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
     txa
     sec
     sbc #$27
     tax
-  //SEG24 [10] phi from main::@3 to main::@2
-  //SEG25 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
-  //SEG26 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
-  //SEG27 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
-  //SEG28 [10] phi from main::@1 to main::@2
-  //SEG29 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG30 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG31 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
-  //SEG32 main::@2
+  //SEG25 [10] phi from main::@3 to main::@2
+  //SEG26 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
+  //SEG27 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
+  //SEG28 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
+  //SEG29 [10] phi from main::@1 to main::@2
+  //SEG30 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
+  //SEG31 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
+  //SEG32 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG33 main::@2
   b2:
-  //SEG33 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
-    lda $4
+  //SEG34 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
+    lda x
     cmp #$28
     bcc b1
-  //SEG34 main::@return
-  //SEG35 [12] return  [ ]
+  //SEG35 main::@return
+  //SEG36 [12] return  [ ]
     rts
 }
 
@@ -2012,113 +2035,117 @@ FINAL SYMBOL TABLE
 (label) main::@3
 (label) main::@return
 (byte*) main::cursor
-(byte*) main::cursor#1 zp ptr byte:2 8.25
-(byte*) main::cursor#2 zp ptr byte:2 11.0
-(byte*) main::cursor#3 zp ptr byte:2 11.0
-(byte*) main::cursor#5 zp ptr byte:2 16.5
+(byte*) main::cursor#1 zp ZP_PTR_BYTE:2 cursor 8.25
+(byte*) main::cursor#2 zp ZP_PTR_BYTE:2 cursor 11.0
+(byte*) main::cursor#3 zp ZP_PTR_BYTE:2 cursor 11.0
+(byte*) main::cursor#5 zp ZP_PTR_BYTE:2 cursor 16.5
 (byte) main::e
 (byte) main::e#1 reg byte x 11.0
 (byte) main::e#2 reg byte x 22.0
 (byte) main::e#3 reg byte x 5.5
 (byte) main::e#5 reg byte x 16.5
 (byte) main::x
-(byte) main::x#1 zp byte:4 3.666666666666667
-(byte) main::x#2 zp byte:4 11.0
+(byte) main::x#1 zp ZP_BYTE:4 x 3.666666666666667
+(byte) main::x#2 zp ZP_BYTE:4 x 11.0
 (byte) main::x0
 (byte) main::x1
 (byte) main::xd
 (byte) main::y
-(byte) main::y#1 zp byte:5 7.333333333333333
-(byte) main::y#2 zp byte:5 5.5
-(byte) main::y#4 zp byte:5 16.5
+(byte) main::y#1 zp ZP_BYTE:5 y 7.333333333333333
+(byte) main::y#2 zp ZP_BYTE:5 y 5.5
+(byte) main::y#4 zp ZP_BYTE:5 y 16.5
 (byte) main::y0
 (byte) main::y1
 (byte) main::yd
 
-zp ptr byte:2 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
-zp byte:4 [ main::x#2 main::x#1 ]
+zp ZP_PTR_BYTE:2 cursor [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
+zp ZP_BYTE:4 x [ main::x#2 main::x#1 ]
 reg byte x [ main::e#3 main::e#5 main::e#1 main::e#2 ]
-zp byte:5 [ main::y#2 main::y#4 main::y#1 ]
+zp ZP_BYTE:5 y [ main::y#2 main::y#4 main::y#1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
+    .label x = 4
+    .label cursor = 2
+    .label y = 5
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::y#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $5
-  //SEG6 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
+    sta y
+  //SEG7 [1] phi (byte) main::e#3 = (byte) 12 -- xby=coby1 
     ldx #$c
-  //SEG7 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [1] phi (byte) main::x#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $4
-  //SEG8 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
+    sta x
+  //SEG9 [1] phi (byte*) main::cursor#3 = (word) 1024 -- zpptrby1=cowo1 
     lda #<$400
-    sta $2
+    sta cursor
     lda #>$400
-    sta $2+$1
-  //SEG9 [1] phi from main::@2 to main::@1
-  //SEG10 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
-  //SEG11 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
-  //SEG12 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
-  //SEG13 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
-  //SEG14 main::@1
+    sta cursor+$1
+  //SEG10 [1] phi from main::@2 to main::@1
+  //SEG11 [1] phi (byte) main::y#2 = (byte) main::y#4 -- register_copy 
+  //SEG12 [1] phi (byte) main::e#3 = (byte) main::e#5 -- register_copy 
+  //SEG13 [1] phi (byte) main::x#2 = (byte) main::x#1 -- register_copy 
+  //SEG14 [1] phi (byte*) main::cursor#3 = (byte*) main::cursor#5 -- register_copy 
+  //SEG15 main::@1
   b1:
-  //SEG15 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
+  //SEG16 [2] *((byte*) main::cursor#3) ← (byte) 81 [ main::cursor#3 main::x#2 main::e#3 main::y#2 ] -- _star_zpptrby1=coby1 
     ldy #$0
     lda #$51
-    sta ($2),y
-  //SEG16 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
-    inc $4
-  //SEG17 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
-    inc $2
+    sta (cursor),y
+  //SEG17 [3] (byte) main::x#1 ← (byte) main::x#2 + (byte) 1 [ main::x#1 main::cursor#3 main::e#3 main::y#2 ] -- zpby1=zpby1_plus_1 
+    inc x
+  //SEG18 [4] (byte*) main::cursor#1 ← (byte*) main::cursor#3 + (byte) 1 [ main::x#1 main::e#3 main::y#2 main::cursor#1 ] -- zpptrby1=zpptrby1_plus_1 
+    inc cursor
     bne !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG18 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
+  //SEG19 [5] (byte) main::e#1 ← (byte) main::e#3 + (byte) 24 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- xby=xby_plus_coby1 
     txa
     clc
     adc #$18
     tax
-  //SEG19 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
+  //SEG20 [6] if((byte) 39>=(byte) main::e#1) goto main::@2 [ main::x#1 main::e#1 main::y#2 main::cursor#1 ] -- coby1_ge_xby_then_la1 
     cpx #$27
     bcc b2
-  //SEG20 main::@3
-  //SEG21 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
-    inc $5
-  //SEG22 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
-    lda $2
+  //SEG21 main::@3
+  //SEG22 [7] (byte) main::y#1 ← (byte) main::y#2 + (byte) 1 [ main::x#1 main::e#1 main::cursor#1 main::y#1 ] -- zpby1=zpby1_plus_1 
+    inc y
+  //SEG23 [8] (byte*) main::cursor#2 ← (byte*) main::cursor#1 + (byte) 40 [ main::x#1 main::e#1 main::cursor#2 main::y#1 ] -- zpptrby1=zpptrby1_plus_coby1 
+    lda cursor
     clc
     adc #$28
-    sta $2
+    sta cursor
     bcc !+
-    inc $2+$1
+    inc cursor+$1
   !:
-  //SEG23 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
+  //SEG24 [9] (byte) main::e#2 ← (byte) main::e#1 - (byte) 39 [ main::x#1 main::cursor#2 main::e#2 main::y#1 ] -- xby=xby_minus_coby1 
     txa
     sec
     sbc #$27
     tax
-  //SEG24 [10] phi from main::@3 to main::@2
-  //SEG25 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
-  //SEG26 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
-  //SEG27 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
-  //SEG28 [10] phi from main::@1 to main::@2
-  //SEG29 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
-  //SEG30 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
-  //SEG31 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
-  //SEG32 main::@2
+  //SEG25 [10] phi from main::@3 to main::@2
+  //SEG26 [10] phi (byte) main::y#4 = (byte) main::y#1 -- register_copy 
+  //SEG27 [10] phi (byte) main::e#5 = (byte) main::e#2 -- register_copy 
+  //SEG28 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#2 -- register_copy 
+  //SEG29 [10] phi from main::@1 to main::@2
+  //SEG30 [10] phi (byte) main::y#4 = (byte) main::y#2 -- register_copy 
+  //SEG31 [10] phi (byte) main::e#5 = (byte) main::e#1 -- register_copy 
+  //SEG32 [10] phi (byte*) main::cursor#5 = (byte*) main::cursor#1 -- register_copy 
+  //SEG33 main::@2
   b2:
-  //SEG33 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
-    lda $4
+  //SEG34 [11] if((byte) main::x#1<(byte) 40) goto main::@1 [ main::cursor#5 main::x#1 main::e#5 main::y#4 ] -- zpby1_lt_coby1_then_la1 
+    lda x
     cmp #$28
     bcc b1
-  //SEG34 main::@return
-  //SEG35 [12] return  [ ]
+  //SEG35 main::@return
+  //SEG36 [12] return  [ ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/bresenham.sym

@@ -8,30 +8,30 @@
 (label) main::@3
 (label) main::@return
 (byte*) main::cursor
-(byte*) main::cursor#1 zp ptr byte:2 8.25
-(byte*) main::cursor#2 zp ptr byte:2 11.0
-(byte*) main::cursor#3 zp ptr byte:2 11.0
-(byte*) main::cursor#5 zp ptr byte:2 16.5
+(byte*) main::cursor#1 zp ZP_PTR_BYTE:2 cursor 8.25
+(byte*) main::cursor#2 zp ZP_PTR_BYTE:2 cursor 11.0
+(byte*) main::cursor#3 zp ZP_PTR_BYTE:2 cursor 11.0
+(byte*) main::cursor#5 zp ZP_PTR_BYTE:2 cursor 16.5
 (byte) main::e
 (byte) main::e#1 reg byte x 11.0
 (byte) main::e#2 reg byte x 22.0
 (byte) main::e#3 reg byte x 5.5
 (byte) main::e#5 reg byte x 16.5
 (byte) main::x
-(byte) main::x#1 zp byte:4 3.666666666666667
-(byte) main::x#2 zp byte:4 11.0
+(byte) main::x#1 zp ZP_BYTE:4 x 3.666666666666667
+(byte) main::x#2 zp ZP_BYTE:4 x 11.0
 (byte) main::x0
 (byte) main::x1
 (byte) main::xd
 (byte) main::y
-(byte) main::y#1 zp byte:5 7.333333333333333
-(byte) main::y#2 zp byte:5 5.5
-(byte) main::y#4 zp byte:5 16.5
+(byte) main::y#1 zp ZP_BYTE:5 y 7.333333333333333
+(byte) main::y#2 zp ZP_BYTE:5 y 5.5
+(byte) main::y#4 zp ZP_BYTE:5 y 16.5
 (byte) main::y0
 (byte) main::y1
 (byte) main::yd
 
-zp ptr byte:2 [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
-zp byte:4 [ main::x#2 main::x#1 ]
+zp ZP_PTR_BYTE:2 cursor [ main::cursor#3 main::cursor#5 main::cursor#1 main::cursor#2 ]
+zp ZP_BYTE:4 x [ main::x#2 main::x#1 ]
 reg byte x [ main::e#3 main::e#5 main::e#1 main::e#2 ]
-zp byte:5 [ main::y#2 main::y#4 main::y#1 ]
+zp ZP_BYTE:5 y [ main::y#2 main::y#4 main::y#1 ]

src/main/java/dk/camelot64/kickc/test/ref/fibmem.log

@@ -590,65 +590,70 @@ Complete equivalence classes
 [ main::$1 ]
 [ main::$3 ]
 [ main::$4 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
-Allocated zp byte:3 [ main::$1 ]
-Allocated zp byte:4 [ main::$3 ]
-Allocated zp byte:5 [ main::$4 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:3 $1 [ main::$1 ]
+Allocated zp ZP_BYTE:4 $3 [ main::$3 ]
+Allocated zp ZP_BYTE:5 $4 [ main::$4 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
+    .label $1 = 3
+    .label $3 = 4
+    .label $4 = 5
+    .label i = 2
+  //SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
     lda #$0
     sta $1100
-  //SEG5 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $1101
-  //SEG6 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1
   b1_from_main:
-  //SEG7 [3] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $2
+    sta i
     jmp b1
-  //SEG8 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1
   b1_from_b1:
-  //SEG9 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG10 main::@1
+  //SEG11 main::@1
   b1:
-  //SEG11 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- zpby1=cowo1_staridx_zpby2 
-    ldx $2
+  //SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- zpby1=cowo1_staridx_zpby2 
+    ldx i
     lda $1100,x
-    sta $3
-  //SEG12 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ] -- zpby1=cowo1_staridx_zpby2 
-    ldx $2
+    sta $1
+  //SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ] -- zpby1=cowo1_staridx_zpby2 
+    ldx i
     lda $1101,x
-    sta $4
-  //SEG13 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- zpby1=zpby2_plus_zpby3 
-    lda $3
+    sta $3
+  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- zpby1=zpby2_plus_zpby3 
+    lda $1
     clc
-    adc $4
-    sta $5
-  //SEG14 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby2 
-    lda $5
-    ldx $2
+    adc $3
+    sta $4
+  //SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby2 
+    lda $4
+    ldx i
     sta $1102,x
-  //SEG15 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
-    inc $2
-  //SEG16 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
-    lda $2
+  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
+    inc i
+  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
+    lda i
     cmp #$f
     bcc b1_from_b1
     jmp breturn
-  //SEG17 main::@return
+  //SEG18 main::@return
   breturn:
-  //SEG18 [10] return  [ ]
+  //SEG19 [10] return  [ ]
     rts
 }
 
@@ -656,15 +661,15 @@ Statement [1] *((word) 4352) ← (byte) 0 [ ] always clobbers reg byte a
 Statement [2] *((word) 4353) ← (byte) 1 [ ] always clobbers reg byte a 
 Statement [1] *((word) 4352) ← (byte) 0 [ ] always clobbers reg byte a 
 Statement [2] *((word) 4353) ← (byte) 1 [ ] always clobbers reg byte a 
-Equivalence Class zp byte:4 [ main::$3 ] has ALU potential.
+Equivalence Class zp ZP_BYTE:4 $3 [ main::$3 ] has ALU potential.
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ main::$1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:4 [ main::$3 ] : zp byte:4 , reg byte a , reg byte x , reg byte y , reg byte alu , 
-Potential registers zp byte:5 [ main::$4 ] : zp byte:5 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 $1 [ main::$1 ] : zp ZP_BYTE:3 $1 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:4 $3 [ main::$3 ] : zp ZP_BYTE:4 $3 , reg byte a , reg byte x , reg byte y , reg byte alu , 
+Potential registers zp ZP_BYTE:5 $4 [ main::$4 ] : zp ZP_BYTE:5 $4 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 27.5: zp byte:2 [ main::i#2 main::i#1 ] 22: zp byte:4 [ main::$3 ] 22: zp byte:5 [ main::$4 ] 11: zp byte:3 [ main::$1 ] 
+Uplift Scope [main] 27.5: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 22: zp ZP_BYTE:4 $3 [ main::$3 ] 22: zp ZP_BYTE:5 $4 [ main::$4 ] 11: zp ZP_BYTE:3 $1 [ main::$1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 362 combination reg byte x [ main::i#2 main::i#1 ] reg byte alu [ main::$3 ] reg byte a [ main::$4 ] reg byte a [ main::$1 ] 
@@ -731,47 +736,48 @@ Removing instruction jmp b1
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
     lda #$0
     sta $1100
-  //SEG5 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $1101
-  //SEG6 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1
   b1_from_main:
-  //SEG7 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG8 [3] phi from main::@1 to main::@1
+  //SEG9 [3] phi from main::@1 to main::@1
   b1_from_b1:
-  //SEG9 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG10 main::@1
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG11 main::@1
   b1:
-  //SEG11 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
     lda $1100,x
-  //SEG12 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
+  //SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
     // [5] main::$3 ← 4353 *idx main::i#2  //  ALU
-  //SEG13 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
+  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
     clc
     adc $1101,x
-  //SEG14 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
+  //SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
     sta $1102,x
-  //SEG15 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG16 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$f
     bcc b1_from_b1
-  //SEG17 main::@return
+  //SEG18 main::@return
   breturn:
-  //SEG18 [10] return  [ ]
+  //SEG19 [10] return  [ ]
     rts
 }
 
@@ -779,46 +785,47 @@ Replacing label b1_from_b1 with b1
 Removing instruction b1_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
     lda #$0
     sta $1100
-  //SEG5 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $1101
-  //SEG6 [3] phi from main to main::@1
+  //SEG7 [3] phi from main to main::@1
   b1_from_main:
-  //SEG7 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG8 [3] phi from main::@1 to main::@1
-  //SEG9 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG10 main::@1
+  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG11 main::@1
   b1:
-  //SEG11 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
     lda $1100,x
-  //SEG12 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
+  //SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
     // [5] main::$3 ← 4353 *idx main::i#2  //  ALU
-  //SEG13 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
+  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
     clc
     adc $1101,x
-  //SEG14 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
+  //SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
     sta $1102,x
-  //SEG15 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG16 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$f
     bcc b1
-  //SEG17 main::@return
+  //SEG18 main::@return
   breturn:
-  //SEG18 [10] return  [ ]
+  //SEG19 [10] return  [ ]
     rts
 }
 
@@ -828,83 +835,85 @@ Removing instruction b1_from_main:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
     lda #$0
     sta $1100
-  //SEG5 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $1101
-  //SEG6 [3] phi from main to main::@1
-  //SEG7 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG8 [3] phi from main::@1 to main::@1
-  //SEG9 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG10 main::@1
+  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG11 main::@1
   b1:
-  //SEG11 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
     lda $1100,x
-  //SEG12 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
+  //SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
     // [5] main::$3 ← 4353 *idx main::i#2  //  ALU
-  //SEG13 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
+  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
     clc
     adc $1101,x
-  //SEG14 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
+  //SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
     sta $1102,x
-  //SEG15 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG16 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$f
     bcc b1
-  //SEG17 main::@return
-  //SEG18 [10] return  [ ]
+  //SEG18 main::@return
+  //SEG19 [10] return  [ ]
     rts
 }
 
 Removing instruction jmp b1
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
     lda #$0
     sta $1100
-  //SEG5 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $1101
-  //SEG6 [3] phi from main to main::@1
-  //SEG7 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG8 [3] phi from main::@1 to main::@1
-  //SEG9 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG10 main::@1
+  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG11 main::@1
   b1:
-  //SEG11 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
     lda $1100,x
-  //SEG12 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
+  //SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
     // [5] main::$3 ← 4353 *idx main::i#2  //  ALU
-  //SEG13 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
+  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
     clc
     adc $1101,x
-  //SEG14 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
+  //SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
     sta $1102,x
-  //SEG15 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG16 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$f
     bcc b1
-  //SEG17 main::@return
-  //SEG18 [10] return  [ ]
+  //SEG18 main::@return
+  //SEG19 [10] return  [ ]
     rts
 }
 
@@ -928,41 +937,42 @@ reg byte alu [ main::$3 ]
 reg byte a [ main::$4 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 4352) ← (byte) 0 [ ] -- _star_cowo1=coby2 
     lda #$0
     sta $1100
-  //SEG5 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG6 [2] *((word) 4353) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $1101
-  //SEG6 [3] phi from main to main::@1
-  //SEG7 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [3] phi from main to main::@1
+  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG8 [3] phi from main::@1 to main::@1
-  //SEG9 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG10 main::@1
+  //SEG9 [3] phi from main::@1 to main::@1
+  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG11 main::@1
   b1:
-  //SEG11 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte~) main::$1 ← (word) 4352 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
     lda $1100,x
-  //SEG12 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
+  //SEG13 [5] (byte~) main::$3 ← (word) 4353 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
     // [5] main::$3 ← 4353 *idx main::i#2  //  ALU
-  //SEG13 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
+  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
     clc
     adc $1101,x
-  //SEG14 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
+  //SEG15 [7] *((word) 4354 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
     sta $1102,x
-  //SEG15 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG16 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$f
     bcc b1
-  //SEG17 main::@return
-  //SEG18 [10] return  [ ]
+  //SEG18 main::@return
+  //SEG19 [10] return  [ ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/flipper-rex2.asm

@@ -22,42 +22,46 @@ main: {
     rts
 }
 plot: {
+    .label line = 2
+    .label y = 4
     lda #$10
-    sta $4
+    sta y
     lda #<$4d4
-    sta $2
+    sta line
     lda #>$4d4
-    sta $2+$1
+    sta line+$1
     ldx #$0
   b1:
     ldy #$0
   b2:
     lda $1000,x
-    sta ($2),y
+    sta (line),y
     inx
     iny
     cpy #$10
     bcc b2
-    lda $2
+    lda line
     clc
     adc #$28
-    sta $2
+    sta line
     bcc !+
-    inc $2+$1
+    inc line+$1
   !:
-    dec $4
-    lda $4
+    dec y
+    lda y
     bne b1
     rts
 }
 flip: {
+    .label c = 5
+    .label y = 4
     lda #$10
-    sta $4
+    sta plot.y
     ldy #$f
     ldx #$0
   b1:
     lda #$10
-    sta $5
+    sta c
   b2:
     lda $1000,x
     sta $1100,y
@@ -66,12 +70,12 @@ flip: {
     clc
     adc #$10
     tay
-    dec $5
-    lda $5
+    dec c
+    lda c
     bne b2
     dey
-    dec $4
-    lda $4
+    dec plot.y
+    lda plot.y
     bne b1
     ldx #$0
   b3:

src/main/java/dk/camelot64/kickc/test/ref/flipper-rex2.sym

@@ -13,8 +13,8 @@
 (label) flip::@4
 (label) flip::@return
 (byte) flip::c
-(byte) flip::c#1 zp byte:5 1501.5
-(byte) flip::c#2 zp byte:5 400.4
+(byte) flip::c#1 zp ZP_BYTE:5 c 1501.5
+(byte) flip::c#2 zp ZP_BYTE:5 c 400.4
 (byte) flip::dstIdx
 (byte) flip::dstIdx#1 reg byte y 701.0
 (byte) flip::dstIdx#2 reg byte y 67.33333333333333
@@ -24,8 +24,8 @@
 (byte) flip::i#1 reg byte x 151.5
 (byte) flip::i#2 reg byte x 134.66666666666666
 (byte) flip::r
-(byte) flip::r#1 zp byte:4 151.5
-(byte) flip::r#2 zp byte:4 22.444444444444443
+(byte) flip::r#1 zp ZP_BYTE:4 y 151.5
+(byte) flip::r#2 zp ZP_BYTE:4 y 22.444444444444443
 (byte) flip::srcIdx
 (byte) flip::srcIdx#1 reg byte x 300.42857142857144
 (byte) flip::srcIdx#2 reg byte x 1034.6666666666667
@@ -54,14 +54,14 @@
 (byte) plot::i#2 reg byte x 1034.6666666666667
 (byte) plot::i#3 reg byte x 202.0
 (byte*) plot::line
-(byte*) plot::line#1 zp ptr byte:2 67.33333333333333
-(byte*) plot::line#2 zp ptr byte:2 171.85714285714283
+(byte*) plot::line#1 zp ZP_PTR_BYTE:2 line 67.33333333333333
+(byte*) plot::line#2 zp ZP_PTR_BYTE:2 line 171.85714285714283
 (byte) plot::x
 (byte) plot::x#1 reg byte y 1501.5
 (byte) plot::x#2 reg byte y 750.75
 (byte) plot::y
-(byte) plot::y#1 zp byte:4 151.5
-(byte) plot::y#2 zp byte:4 25.25
+(byte) plot::y#1 zp ZP_BYTE:4 y 151.5
+(byte) plot::y#2 zp ZP_BYTE:4 y 25.25
 (void()) prepare()
 (label) prepare::@1
 (label) prepare::@return
@@ -70,13 +70,13 @@
 (byte) prepare::i#2 reg byte x 22.0
 
 reg byte x [ main::c#2 main::c#1 ]
-zp ptr byte:2 [ plot::line#2 plot::line#1 ]
-zp byte:4 [ plot::y#2 plot::y#1 flip::r#2 flip::r#1 ]
+zp ZP_PTR_BYTE:2 line [ plot::line#2 plot::line#1 ]
+zp ZP_BYTE:4 y [ plot::y#2 plot::y#1 flip::r#2 flip::r#1 ]
 reg byte x [ plot::i#2 plot::i#3 plot::i#1 ]
 reg byte y [ plot::x#2 plot::x#1 ]
 reg byte x [ flip::srcIdx#2 flip::srcIdx#3 flip::srcIdx#1 ]
 reg byte y [ flip::dstIdx#3 flip::dstIdx#5 flip::dstIdx#2 flip::dstIdx#1 ]
-zp byte:5 [ flip::c#2 flip::c#1 ]
+zp ZP_BYTE:5 c [ flip::c#2 flip::c#1 ]
 reg byte x [ flip::i#2 flip::i#1 ]
 reg byte x [ prepare::i#2 prepare::i#1 ]
 reg byte a [ main::$1 ]

src/main/java/dk/camelot64/kickc/test/ref/forclassicmin.log

@@ -468,54 +468,56 @@ Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
   jmp b1
-//SEG1 @1
+//SEG2 @1
 b1:
-//SEG2 [0] call main param-assignment [ ]
+//SEG3 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG3 @end
+//SEG4 @end
 bend:
-//SEG4 main
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
+    .label i = 2
+  //SEG6 [1] phi from main to main::@1
   b1_from_main:
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $2
+    sta i
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
   b1_from_b1:
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG9 main::@1
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby1 
-    ldx $2
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby1 
+    ldx i
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
-    inc $2
-  //SEG12 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_neq_coby1_then_la1 
-    lda $2
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
+    inc i
+  //SEG13 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_neq_coby1_then_la1 
+    lda i
     cmp #$64
     bne b1_from_b1
     jmp breturn
-  //SEG13 main::@return
+  //SEG14 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG15 [5] return  [ ]
     rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 38.5: zp byte:2 [ main::i#2 main::i#1 ] 
+Uplift Scope [main] 38.5: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 290 combination reg byte x [ main::i#2 main::i#1 ] 
@@ -526,37 +528,38 @@ Removing instruction jmp b1
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 @1
+//SEG2 @1
 b1:
-//SEG2 [0] call main param-assignment [ ]
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
+//SEG4 @end
 bend:
-//SEG4 main
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi from main to main::@1
   b1_from_main:
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
   b1_from_b1:
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
     cpx #$64
     bne b1_from_b1
-  //SEG13 main::@return
+  //SEG14 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG15 [5] return  [ ]
     rts
 }
 
@@ -565,35 +568,36 @@ Removing instruction bbegin:
 Removing instruction b1_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 @1
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
 b1:
-//SEG2 [0] call main param-assignment [ ]
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
+//SEG4 @end
 bend:
-//SEG4 main
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi from main to main::@1
   b1_from_main:
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
     cpx #$64
     bne b1
-  //SEG13 main::@return
+  //SEG14 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG15 [5] return  [ ]
     rts
 }
 
@@ -603,61 +607,63 @@ Removing instruction b1_from_main:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 @1
-//SEG2 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
-//SEG4 main
+//SEG4 @end
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi from main to main::@1
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
     cpx #$64
     bne b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG14 main::@return
+  //SEG15 [5] return  [ ]
     rts
 }
 
 Removing instruction jmp b1
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 @1
-//SEG2 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
-//SEG4 main
+//SEG4 @end
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi from main to main::@1
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
     cpx #$64
     bne b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG14 main::@return
+  //SEG15 [5] return  [ ]
     rts
 }
 
@@ -676,30 +682,31 @@ FINAL SYMBOL TABLE
 reg byte x [ main::i#2 main::i#1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 @1
-//SEG2 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
-//SEG4 main
+//SEG4 @end
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi from main to main::@1
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 100) goto main::@1 [ main::i#1 ] -- xby_neq_coby1_then_la1 
     cpx #$64
     bne b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG14 main::@return
+  //SEG15 [5] return  [ ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/forrangemin.log

@@ -753,77 +753,80 @@ Initial phi equivalence classes
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
 [ main::j#2 main::j#1 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
-Allocated zp byte:3 [ main::j#2 main::j#1 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:3 j#2 [ main::j#2 main::j#1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
   jmp b1
-//SEG1 @1
+//SEG2 @1
 b1:
-//SEG2 [0] call main param-assignment [ ]
+//SEG3 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG3 @end
+//SEG4 @end
 bend:
-//SEG4 main
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
+    .label i = 2
+    .label j = 3
+  //SEG6 [1] phi from main to main::@1
   b1_from_main:
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $2
+    sta i
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
   b1_from_b1:
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG9 main::@1
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby1 
-    ldx $2
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby1 
+    ldx i
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
-    inc $2
-  //SEG12 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- zpby1_neq_0_then_la1 
-    lda $2
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
+    inc i
+  //SEG13 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- zpby1_neq_0_then_la1 
+    lda i
     bne b1_from_b1
-  //SEG13 [5] phi from main::@1 to main::@2
+  //SEG14 [5] phi from main::@1 to main::@2
   b2_from_b1:
-  //SEG14 [5] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG15 [5] phi (byte) main::j#2 = (byte) 100 -- zpby1=coby1 
     lda #$64
-    sta $3
+    sta j
     jmp b2
-  //SEG15 [5] phi from main::@2 to main::@2
+  //SEG16 [5] phi from main::@2 to main::@2
   b2_from_b2:
-  //SEG16 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG17 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
     jmp b2
-  //SEG17 main::@2
+  //SEG18 main::@2
   b2:
-  //SEG18 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_zpby1=zpby1 
-    ldx $3
+  //SEG19 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_zpby1=zpby1 
+    ldx j
     txa
     sta $500,x
-  //SEG19 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- zpby1=_dec_zpby1 
-    dec $3
-  //SEG20 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- zpby1_neq_coby1_then_la1 
-    lda $3
+  //SEG20 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- zpby1=_dec_zpby1 
+    dec j
+  //SEG21 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- zpby1_neq_coby1_then_la1 
+    lda j
     cmp #$ff
     bne b2_from_b2
     jmp breturn
-  //SEG21 main::@return
+  //SEG22 main::@return
   breturn:
-  //SEG22 [9] return  [ ]
+  //SEG23 [9] return  [ ]
     rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ main::j#2 main::j#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 j [ main::j#2 main::j#1 ] : zp ZP_BYTE:3 j , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 38.5: zp byte:2 [ main::i#2 main::i#1 ] 38.5: zp byte:3 [ main::j#2 main::j#1 ] 
+Uplift Scope [main] 38.5: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 38.5: zp ZP_BYTE:3 j [ main::j#2 main::j#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 505 combination reg byte x [ main::i#2 main::i#1 ] reg byte x [ main::j#2 main::j#1 ] 
@@ -835,55 +838,56 @@ Removing instruction jmp b2
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 @1
+//SEG2 @1
 b1:
-//SEG2 [0] call main param-assignment [ ]
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
+//SEG4 @end
 bend:
-//SEG4 main
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi from main to main::@1
   b1_from_main:
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
   b1_from_b1:
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #$0
     bne b1_from_b1
-  //SEG13 [5] phi from main::@1 to main::@2
+  //SEG14 [5] phi from main::@1 to main::@2
   b2_from_b1:
-  //SEG14 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG15 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
     jmp b2
-  //SEG15 [5] phi from main::@2 to main::@2
+  //SEG16 [5] phi from main::@2 to main::@2
   b2_from_b2:
-  //SEG16 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
-  //SEG17 main::@2
+  //SEG17 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 main::@2
   b2:
-  //SEG18 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
+  //SEG19 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $500,x
-  //SEG19 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
+  //SEG20 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG20 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
+  //SEG21 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
     cpx #$ff
     bne b2_from_b2
-  //SEG21 main::@return
+  //SEG22 main::@return
   breturn:
-  //SEG22 [9] return  [ ]
+  //SEG23 [9] return  [ ]
     rts
 }
 
@@ -894,52 +898,53 @@ Removing instruction b1_from_b1:
 Removing instruction b2_from_b2:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 @1
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
 b1:
-//SEG2 [0] call main param-assignment [ ]
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
+//SEG4 @end
 bend:
-//SEG4 main
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi from main to main::@1
   b1_from_main:
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #$0
     bne b1
-  //SEG13 [5] phi from main::@1 to main::@2
+  //SEG14 [5] phi from main::@1 to main::@2
   b2_from_b1:
-  //SEG14 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG15 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
     jmp b2
-  //SEG15 [5] phi from main::@2 to main::@2
-  //SEG16 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
-  //SEG17 main::@2
+  //SEG16 [5] phi from main::@2 to main::@2
+  //SEG17 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 main::@2
   b2:
-  //SEG18 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
+  //SEG19 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $500,x
-  //SEG19 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
+  //SEG20 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG20 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
+  //SEG21 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
     cpx #$ff
     bne b2
-  //SEG21 main::@return
+  //SEG22 main::@return
   breturn:
-  //SEG22 [9] return  [ ]
+  //SEG23 [9] return  [ ]
     rts
 }
 
@@ -950,47 +955,48 @@ Removing instruction b2_from_b1:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 @1
-//SEG2 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
-//SEG4 main
+//SEG4 @end
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi from main to main::@1
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #$0
     bne b1
-  //SEG13 [5] phi from main::@1 to main::@2
-  //SEG14 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG14 [5] phi from main::@1 to main::@2
+  //SEG15 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
     jmp b2
-  //SEG15 [5] phi from main::@2 to main::@2
-  //SEG16 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
-  //SEG17 main::@2
+  //SEG16 [5] phi from main::@2 to main::@2
+  //SEG17 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 main::@2
   b2:
-  //SEG18 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
+  //SEG19 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $500,x
-  //SEG19 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
+  //SEG20 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG20 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
+  //SEG21 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
     cpx #$ff
     bne b2
-  //SEG21 main::@return
-  //SEG22 [9] return  [ ]
+  //SEG22 main::@return
+  //SEG23 [9] return  [ ]
     rts
 }
 
@@ -998,45 +1004,46 @@ Removing instruction jmp b1
 Removing instruction jmp b2
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 @1
-//SEG2 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
-//SEG4 main
+//SEG4 @end
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi from main to main::@1
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #$0
     bne b1
-  //SEG13 [5] phi from main::@1 to main::@2
-  //SEG14 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG14 [5] phi from main::@1 to main::@2
+  //SEG15 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG15 [5] phi from main::@2 to main::@2
-  //SEG16 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
-  //SEG17 main::@2
+  //SEG16 [5] phi from main::@2 to main::@2
+  //SEG17 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 main::@2
   b2:
-  //SEG18 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
+  //SEG19 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $500,x
-  //SEG19 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
+  //SEG20 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG20 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
+  //SEG21 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
     cpx #$ff
     bne b2
-  //SEG21 main::@return
-  //SEG22 [9] return  [ ]
+  //SEG22 main::@return
+  //SEG23 [9] return  [ ]
     rts
 }
 
@@ -1061,45 +1068,46 @@ reg byte x [ main::i#2 main::i#1 ]
 reg byte x [ main::j#2 main::j#1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 @1
-//SEG2 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 @1
+//SEG3 [0] call main param-assignment [ ]
   jsr main
-//SEG3 @end
-//SEG4 main
+//SEG4 @end
+//SEG5 main
 main: {
-  //SEG5 [1] phi from main to main::@1
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi from main to main::@1
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG7 [1] phi from main::@1 to main::@1
-  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG9 main::@1
+  //SEG8 [1] phi from main::@1 to main::@1
+  //SEG9 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG10 main::@1
   b1:
-  //SEG10 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
+  //SEG11 [2] *((word) 1024 + (byte) main::i#2) ← (byte) main::i#2 [ main::i#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $400,x
-  //SEG11 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG12 [3] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG12 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1!=(byte) 0) goto main::@1 [ main::i#1 ] -- xby_neq_0_then_la1 
     cpx #$0
     bne b1
-  //SEG13 [5] phi from main::@1 to main::@2
-  //SEG14 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
+  //SEG14 [5] phi from main::@1 to main::@2
+  //SEG15 [5] phi (byte) main::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG15 [5] phi from main::@2 to main::@2
-  //SEG16 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
-  //SEG17 main::@2
+  //SEG16 [5] phi from main::@2 to main::@2
+  //SEG17 [5] phi (byte) main::j#2 = (byte) main::j#1 -- register_copy 
+  //SEG18 main::@2
   b2:
-  //SEG18 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
+  //SEG19 [6] *((word) 1280 + (byte) main::j#2) ← (byte) main::j#2 [ main::j#2 ] -- cowo1_staridx_xby=xby 
     txa
     sta $500,x
-  //SEG19 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
+  //SEG20 [7] (byte) main::j#1 ← -- (byte) main::j#2 [ main::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG20 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
+  //SEG21 [8] if((byte) main::j#1!=(byte) 255) goto main::@2 [ main::j#1 ] -- xby_neq_coby1_then_la1 
     cpx #$ff
     bne b2
-  //SEG21 main::@return
-  //SEG22 [9] return  [ ]
+  //SEG22 main::@return
+  //SEG23 [9] return  [ ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/ifmin.log

@@ -596,60 +596,62 @@ Initial phi equivalence classes
 [ main::i#2 main::i#1 ]
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label i = 2
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $2
+    sta i
     jmp b1
-  //SEG6 [1] phi from main::@2 to main::@1
+  //SEG7 [1] phi from main::@2 to main::@1
   b1_from_b2:
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG8 main::@1
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- zpby1_ge_coby1_then_la1 
-    lda $2
+  //SEG10 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- zpby1_ge_coby1_then_la1 
+    lda i
     cmp #$32
     bcs b2
     jmp b3
-  //SEG10 main::@3
+  //SEG11 main::@3
   b3:
-  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=zpby1 
-    lda $2
+  //SEG12 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=zpby1 
+    lda i
     sta $400
     jmp b2
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
-    inc $2
-  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
-    lda $2
+  //SEG14 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
+    inc i
+  //SEG15 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
+    lda i
     cmp #$64
     bcc b1_from_b2
     jmp breturn
-  //SEG15 main::@return
+  //SEG16 main::@return
   breturn:
-  //SEG16 [6] return  [ ]
+  //SEG17 [6] return  [ ]
     rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 31.17: zp byte:2 [ main::i#2 main::i#1 ] 
+Uplift Scope [main] 31.17: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 335 combination reg byte x [ main::i#2 main::i#1 ] 
@@ -661,41 +663,42 @@ Removing instruction jmp b2
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG6 [1] phi from main::@2 to main::@1
+  //SEG7 [1] phi from main::@2 to main::@1
   b1_from_b2:
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
+  //SEG10 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
     bcs b2
-  //SEG10 main::@3
+  //SEG11 main::@3
   b3:
-  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+  //SEG12 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG14 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG15 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1_from_b2
-  //SEG15 main::@return
+  //SEG16 main::@return
   breturn:
-  //SEG16 [6] return  [ ]
+  //SEG17 [6] return  [ ]
     rts
 }
 
@@ -703,40 +706,41 @@ Replacing label b1_from_b2 with b1
 Removing instruction b1_from_b2:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG6 [1] phi from main::@2 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@2 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
+  //SEG10 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
     bcs b2
-  //SEG10 main::@3
+  //SEG11 main::@3
   b3:
-  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+  //SEG12 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG14 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG15 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG15 main::@return
+  //SEG16 main::@return
   breturn:
-  //SEG16 [6] return  [ ]
+  //SEG17 [6] return  [ ]
     rts
 }
 
@@ -747,69 +751,71 @@ Removing instruction b3:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
     jmp b1
-  //SEG6 [1] phi from main::@2 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@2 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
+  //SEG10 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
     bcs b2
-  //SEG10 main::@3
-  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+  //SEG11 main::@3
+  //SEG12 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG14 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG15 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG15 main::@return
-  //SEG16 [6] return  [ ]
+  //SEG16 main::@return
+  //SEG17 [6] return  [ ]
     rts
 }
 
 Removing instruction jmp b1
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG6 [1] phi from main::@2 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@2 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
+  //SEG10 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
     bcs b2
-  //SEG10 main::@3
-  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+  //SEG11 main::@3
+  //SEG12 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG14 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG15 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG15 main::@return
-  //SEG16 [6] return  [ ]
+  //SEG16 main::@return
+  //SEG17 [6] return  [ ]
     rts
 }
 
@@ -829,34 +835,35 @@ FINAL SYMBOL TABLE
 reg byte x [ main::i#2 main::i#1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
     ldx #$0
-  //SEG6 [1] phi from main::@2 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@2 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
+  //SEG10 [2] if((byte) main::i#2>=(byte) 50) goto main::@2 [ main::i#2 ] -- xby_ge_coby1_then_la1 
     cpx #$32
     bcs b2
-  //SEG10 main::@3
-  //SEG11 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
+  //SEG11 main::@3
+  //SEG12 [3] *((word) 1024) ← (byte) main::i#2 [ main::i#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG14 [4] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG14 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
+  //SEG15 [5] if((byte) main::i#1<(byte) 100) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
     cpx #$64
     bcc b1
-  //SEG15 main::@return
-  //SEG16 [6] return  [ ]
+  //SEG16 main::@return
+  //SEG17 [6] return  [ ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/loopmin.log

@@ -440,65 +440,68 @@ Initial phi equivalence classes
 Complete equivalence classes
 [ i#2 i#1 ]
 [ s#2 s#4 s#1 ]
-Allocated zp byte:2 [ i#2 i#1 ]
-Allocated zp byte:3 [ s#2 s#4 s#1 ]
+Allocated zp ZP_BYTE:2 i#2 [ i#2 i#1 ]
+Allocated zp ZP_BYTE:3 s#2 [ s#2 s#4 s#1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+  .label i = 2
+  .label s = 3
+//SEG1 @begin
 bbegin:
-//SEG1 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1
 b1_from_bbegin:
-//SEG2 [0] phi (byte) s#2 = (byte) 0 -- zpby1=coby1 
+//SEG3 [0] phi (byte) s#2 = (byte) 0 -- zpby1=coby1 
   lda #$0
-  sta $3
-//SEG3 [0] phi (byte) i#2 = (byte) 10 -- zpby1=coby1 
+  sta s
+//SEG4 [0] phi (byte) i#2 = (byte) 10 -- zpby1=coby1 
   lda #$a
-  sta $2
+  sta i
   jmp b1
-//SEG4 [0] phi from @2 to @1
+//SEG5 [0] phi from @2 to @1
 b1_from_b2:
-//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
   jmp b1
-//SEG7 @1
+//SEG8 @1
 b1:
-//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- zpby1_le_coby1_then_la1 
-  lda $2
+//SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- zpby1_le_coby1_then_la1 
+  lda i
   cmp #$5
   bcc b2_from_b1
   beq b2_from_b1
   jmp b3
-//SEG9 @3
+//SEG10 @3
 b3:
-//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- zpby1=zpby1_plus_zpby2 
-  lda $3
+//SEG11 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- zpby1=zpby1_plus_zpby2 
+  lda s
   clc
-  adc $2
-  sta $3
-//SEG11 [3] phi from @3 to @2
+  adc i
+  sta s
+//SEG12 [3] phi from @3 to @2
 b2_from_b3:
-//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG13 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
   jmp b2
-//SEG13 [3] phi from @1 to @2
+//SEG14 [3] phi from @1 to @2
 b2_from_b1:
-//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG15 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
   jmp b2
-//SEG15 @2
+//SEG16 @2
 b2:
-//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- zpby1=_dec_zpby1 
-  dec $2
-//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- zpby1_gt_0_then_la1 
-  lda $2
+//SEG17 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- zpby1=_dec_zpby1 
+  dec i
+//SEG18 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- zpby1_gt_0_then_la1 
+  lda i
   bne b1_from_b2
   jmp bend
-//SEG18 @end
+//SEG19 @end
 bend:
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ s#2 s#4 s#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ i#2 i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 s [ s#2 s#4 s#1 ] : zp ZP_BYTE:3 s , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 49.5: zp byte:3 [ s#2 s#4 s#1 ] 27.5: zp byte:2 [ i#2 i#1 ] 
+Uplift Scope [] 49.5: zp ZP_BYTE:3 s [ s#2 s#4 s#1 ] 27.5: zp ZP_BYTE:2 i [ i#2 i#1 ] 
 
 Uplifting [] best 435 combination reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ] 
 Removing instruction jmp b1
@@ -507,46 +510,47 @@ Removing instruction jmp b2
 Removing instruction jmp bend
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1
 b1_from_bbegin:
-//SEG2 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
   lda #$0
-//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG4 [0] phi from @2 to @1
+//SEG5 [0] phi from @2 to @1
 b1_from_b2:
-//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG7 @1
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG8 @1
 b1:
-//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
+//SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
   bcc b2_from_b1
   beq b2_from_b1
-//SEG9 @3
+//SEG10 @3
 b3:
-//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG11 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG11 [3] phi from @3 to @2
+//SEG12 [3] phi from @3 to @2
 b2_from_b3:
-//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG13 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
   jmp b2
-//SEG13 [3] phi from @1 to @2
+//SEG14 [3] phi from @1 to @2
 b2_from_b1:
-//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG15 @2
+//SEG15 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG16 @2
 b2:
-//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+//SEG17 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
   dex
-//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+//SEG18 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
   cpx #$0
   bne b1_from_b2
-//SEG18 @end
+//SEG19 @end
 bend:
 
 Replacing label b2_from_b1 with b2
@@ -557,43 +561,44 @@ Removing instruction b1_from_b2:
 Removing instruction b2_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
   lda #$0
-//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG4 [0] phi from @2 to @1
-//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG7 @1
+//SEG5 [0] phi from @2 to @1
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG8 @1
 b1:
-//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
+//SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
   bcc b2
   beq b2
-//SEG9 @3
+//SEG10 @3
 b3:
-//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG11 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG11 [3] phi from @3 to @2
+//SEG12 [3] phi from @3 to @2
 b2_from_b3:
-//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG13 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
   jmp b2
-//SEG13 [3] phi from @1 to @2
-//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG15 @2
+//SEG14 [3] phi from @1 to @2
+//SEG15 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG16 @2
 b2:
-//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+//SEG17 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
   dex
-//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+//SEG18 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
   cpx #$0
   bne b1
-//SEG18 @end
+//SEG19 @end
 bend:
 
 Removing instruction bbegin:
@@ -602,77 +607,79 @@ Removing instruction b2_from_b3:
 Removing instruction bend:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
   lda #$0
-//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
   jmp b1
-//SEG4 [0] phi from @2 to @1
-//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG7 @1
+//SEG5 [0] phi from @2 to @1
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG8 @1
 b1:
-//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
+//SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
   bcc b2
   beq b2
-//SEG9 @3
-//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG10 @3
+//SEG11 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG11 [3] phi from @3 to @2
-//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG12 [3] phi from @3 to @2
+//SEG13 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
   jmp b2
-//SEG13 [3] phi from @1 to @2
-//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG15 @2
+//SEG14 [3] phi from @1 to @2
+//SEG15 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG16 @2
 b2:
-//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+//SEG17 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
   dex
-//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+//SEG18 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
   cpx #$0
   bne b1
-//SEG18 @end
+//SEG19 @end
 
 Removing instruction jmp b1
 Removing instruction jmp b2
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
   lda #$0
-//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
-//SEG4 [0] phi from @2 to @1
-//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG7 @1
+//SEG5 [0] phi from @2 to @1
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG8 @1
 b1:
-//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
+//SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
   bcc b2
   beq b2
-//SEG9 @3
-//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG10 @3
+//SEG11 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG11 [3] phi from @3 to @2
-//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
-//SEG13 [3] phi from @1 to @2
-//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG15 @2
+//SEG12 [3] phi from @3 to @2
+//SEG13 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG14 [3] phi from @1 to @2
+//SEG15 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG16 @2
 b2:
-//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+//SEG17 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
   dex
-//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+//SEG18 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
   cpx #$0
   bne b1
-//SEG18 @end
+//SEG19 @end
 
 FINAL SYMBOL TABLE
 (label) @1
@@ -692,36 +699,37 @@ reg byte x [ i#2 i#1 ]
 reg byte a [ s#2 s#4 s#1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) s#2 = (byte) 0 -- aby=coby1 
   lda #$0
-//SEG3 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
+//SEG4 [0] phi (byte) i#2 = (byte) 10 -- xby=coby1 
   ldx #$a
-//SEG4 [0] phi from @2 to @1
-//SEG5 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
-//SEG6 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG7 @1
+//SEG5 [0] phi from @2 to @1
+//SEG6 [0] phi (byte) s#2 = (byte) s#4 -- register_copy 
+//SEG7 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG8 @1
 b1:
-//SEG8 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
+//SEG9 [1] if((byte) i#2<=(byte) 5) goto @2 [ i#2 s#2 ] -- xby_le_coby1_then_la1 
   cpx #$5
   bcc b2
   beq b2
-//SEG9 @3
-//SEG10 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
+//SEG10 @3
+//SEG11 [2] (byte) s#1 ← (byte) s#2 + (byte) i#2 [ i#2 s#1 ] -- aby=aby_plus_xby 
   stx $ff
   clc
   adc $ff
-//SEG11 [3] phi from @3 to @2
-//SEG12 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
-//SEG13 [3] phi from @1 to @2
-//SEG14 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
-//SEG15 @2
+//SEG12 [3] phi from @3 to @2
+//SEG13 [3] phi (byte) s#4 = (byte) s#1 -- register_copy 
+//SEG14 [3] phi from @1 to @2
+//SEG15 [3] phi (byte) s#4 = (byte) s#2 -- register_copy 
+//SEG16 @2
 b2:
-//SEG16 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
+//SEG17 [4] (byte) i#1 ← -- (byte) i#2 [ i#1 s#4 ] -- xby=_dec_xby 
   dex
-//SEG17 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
+//SEG18 [5] if((byte) i#1>(byte) 0) goto @1 [ i#1 s#4 ] -- xby_gt_0_then_la1 
   cpx #$0
   bne b1
-//SEG18 @end
+//SEG19 @end
 

src/main/java/dk/camelot64/kickc/test/ref/loopnest.log

@@ -781,85 +781,88 @@ Initial phi equivalence classes
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
 [ nest::j#2 nest::j#1 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
-Allocated zp byte:3 [ nest::j#2 nest::j#1 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:3 j#2 [ nest::j#2 nest::j#1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label i = 2
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
     lda #$64
-    sta $2
+    sta i
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
+  //SEG7 [1] phi from main::@3 to main::@1
   b1_from_b3:
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG8 main::@1
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] call nest param-assignment [ main::i#2 ]
+  //SEG10 [2] call nest param-assignment [ main::i#2 ]
     jsr nest
     jmp b3
-  //SEG10 main::@3
+  //SEG11 main::@3
   b3:
-  //SEG11 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- zpby1=_dec_zpby1 
-    dec $2
-  //SEG12 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- zpby1_gt_0_then_la1 
-    lda $2
+  //SEG12 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- zpby1=_dec_zpby1 
+    dec i
+  //SEG13 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- zpby1_gt_0_then_la1 
+    lda i
     bne b1_from_b3
     jmp breturn
-  //SEG13 main::@return
+  //SEG14 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG15 [5] return  [ ]
     rts
 }
-//SEG15 nest
+//SEG16 nest
 nest: {
-  //SEG16 [6] phi from nest to nest::@1
+    .label j = 3
+  //SEG17 [6] phi from nest to nest::@1
   b1_from_nest:
-  //SEG17 [6] phi (byte) nest::j#2 = (byte) 100 -- zpby1=coby1 
+  //SEG18 [6] phi (byte) nest::j#2 = (byte) 100 -- zpby1=coby1 
     lda #$64
-    sta $3
+    sta j
     jmp b1
-  //SEG18 [6] phi from nest::@1 to nest::@1
+  //SEG19 [6] phi from nest::@1 to nest::@1
   b1_from_b1:
-  //SEG19 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG20 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
     jmp b1
-  //SEG20 nest::@1
+  //SEG21 nest::@1
   b1:
-  //SEG21 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=zpby1 
-    lda $3
+  //SEG22 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=zpby1 
+    lda j
     sta $400
-  //SEG22 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- zpby1=_dec_zpby1 
-    dec $3
-  //SEG23 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- zpby1_gt_0_then_la1 
-    lda $3
+  //SEG23 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- zpby1=_dec_zpby1 
+    dec j
+  //SEG24 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- zpby1_gt_0_then_la1 
+    lda j
     bne b1_from_b1
     jmp breturn
-  //SEG24 nest::@return
+  //SEG25 nest::@return
   breturn:
-  //SEG25 [10] return  [ main::i#2 ]
+  //SEG26 [10] return  [ main::i#2 ]
     rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ nest::j#2 nest::j#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 j [ nest::j#2 nest::j#1 ] : zp ZP_BYTE:3 j , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [nest] 303: zp byte:3 [ nest::j#2 nest::j#1 ] 
-Uplift Scope [main] 19.64: zp byte:2 [ main::i#2 main::i#1 ] 
+Uplift Scope [nest] 303: zp ZP_BYTE:3 j [ nest::j#2 nest::j#1 ] 
+Uplift Scope [main] 19.64: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 
 Uplift Scope [] 
 
-Uplifting [nest] best 2506 combination reg byte x [ nest::j#2 nest::j#1 ] 
+Uplifting [nest] best 2536 combination reg byte x [ nest::j#2 nest::j#1 ] 
 Uplifting [main] best 2436 combination reg byte y [ main::i#2 main::i#1 ] 
 Uplifting [] best 2436 combination 
 Removing instruction jmp bend
@@ -870,60 +873,61 @@ Removing instruction jmp b1
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
     ldy #$64
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
+  //SEG7 [1] phi from main::@3 to main::@1
   b1_from_b3:
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] call nest param-assignment [ main::i#2 ]
+  //SEG10 [2] call nest param-assignment [ main::i#2 ]
     jsr nest
-  //SEG10 main::@3
+  //SEG11 main::@3
   b3:
-  //SEG11 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
+  //SEG12 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
     dey
-  //SEG12 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
     cpy #$0
     bne b1_from_b3
-  //SEG13 main::@return
+  //SEG14 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG15 [5] return  [ ]
     rts
 }
-//SEG15 nest
+//SEG16 nest
 nest: {
-  //SEG16 [6] phi from nest to nest::@1
+  //SEG17 [6] phi from nest to nest::@1
   b1_from_nest:
-  //SEG17 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG18 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG18 [6] phi from nest::@1 to nest::@1
+  //SEG19 [6] phi from nest::@1 to nest::@1
   b1_from_b1:
-  //SEG19 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
-  //SEG20 nest::@1
+  //SEG20 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 nest::@1
   b1:
-  //SEG21 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
+  //SEG22 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG22 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
+  //SEG23 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG23 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
+  //SEG24 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b1_from_b1
-  //SEG24 nest::@return
+  //SEG25 nest::@return
   breturn:
-  //SEG25 [10] return  [ main::i#2 ]
+  //SEG26 [10] return  [ main::i#2 ]
     rts
 }
 
@@ -933,58 +937,59 @@ Removing instruction b1_from_b3:
 Removing instruction b1_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
     ldy #$64
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@3 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] call nest param-assignment [ main::i#2 ]
+  //SEG10 [2] call nest param-assignment [ main::i#2 ]
     jsr nest
-  //SEG10 main::@3
+  //SEG11 main::@3
   b3:
-  //SEG11 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
+  //SEG12 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
     dey
-  //SEG12 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
     cpy #$0
     bne b1
-  //SEG13 main::@return
+  //SEG14 main::@return
   breturn:
-  //SEG14 [5] return  [ ]
+  //SEG15 [5] return  [ ]
     rts
 }
-//SEG15 nest
+//SEG16 nest
 nest: {
-  //SEG16 [6] phi from nest to nest::@1
+  //SEG17 [6] phi from nest to nest::@1
   b1_from_nest:
-  //SEG17 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG18 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG18 [6] phi from nest::@1 to nest::@1
-  //SEG19 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
-  //SEG20 nest::@1
+  //SEG19 [6] phi from nest::@1 to nest::@1
+  //SEG20 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 nest::@1
   b1:
-  //SEG21 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
+  //SEG22 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG22 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
+  //SEG23 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG23 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
+  //SEG24 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b1
-  //SEG24 nest::@return
+  //SEG25 nest::@return
   breturn:
-  //SEG25 [10] return  [ main::i#2 ]
+  //SEG26 [10] return  [ main::i#2 ]
     rts
 }
 
@@ -997,51 +1002,52 @@ Removing instruction b1_from_nest:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
     ldy #$64
     jmp b1
-  //SEG6 [1] phi from main::@3 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@3 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] call nest param-assignment [ main::i#2 ]
+  //SEG10 [2] call nest param-assignment [ main::i#2 ]
     jsr nest
-  //SEG10 main::@3
-  //SEG11 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
+  //SEG11 main::@3
+  //SEG12 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
     dey
-  //SEG12 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
     cpy #$0
     bne b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG14 main::@return
+  //SEG15 [5] return  [ ]
     rts
 }
-//SEG15 nest
+//SEG16 nest
 nest: {
-  //SEG16 [6] phi from nest to nest::@1
-  //SEG17 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG17 [6] phi from nest to nest::@1
+  //SEG18 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
     jmp b1
-  //SEG18 [6] phi from nest::@1 to nest::@1
-  //SEG19 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
-  //SEG20 nest::@1
+  //SEG19 [6] phi from nest::@1 to nest::@1
+  //SEG20 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 nest::@1
   b1:
-  //SEG21 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
+  //SEG22 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG22 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
+  //SEG23 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG23 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
+  //SEG24 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b1
-  //SEG24 nest::@return
-  //SEG25 [10] return  [ main::i#2 ]
+  //SEG25 nest::@return
+  //SEG26 [10] return  [ main::i#2 ]
     rts
 }
 
@@ -1049,49 +1055,50 @@ Removing instruction jmp b1
 Removing instruction jmp b1
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
     ldy #$64
-  //SEG6 [1] phi from main::@3 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@3 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] call nest param-assignment [ main::i#2 ]
+  //SEG10 [2] call nest param-assignment [ main::i#2 ]
     jsr nest
-  //SEG10 main::@3
-  //SEG11 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
+  //SEG11 main::@3
+  //SEG12 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
     dey
-  //SEG12 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
     cpy #$0
     bne b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG14 main::@return
+  //SEG15 [5] return  [ ]
     rts
 }
-//SEG15 nest
+//SEG16 nest
 nest: {
-  //SEG16 [6] phi from nest to nest::@1
-  //SEG17 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG17 [6] phi from nest to nest::@1
+  //SEG18 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG18 [6] phi from nest::@1 to nest::@1
-  //SEG19 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
-  //SEG20 nest::@1
+  //SEG19 [6] phi from nest::@1 to nest::@1
+  //SEG20 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 nest::@1
   b1:
-  //SEG21 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
+  //SEG22 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG22 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
+  //SEG23 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG23 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
+  //SEG24 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b1
-  //SEG24 nest::@return
-  //SEG25 [10] return  [ main::i#2 ]
+  //SEG25 nest::@return
+  //SEG26 [10] return  [ main::i#2 ]
     rts
 }
 
@@ -1117,49 +1124,50 @@ reg byte y [ main::i#2 main::i#1 ]
 reg byte x [ nest::j#2 nest::j#1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- yby=coby1 
     ldy #$64
-  //SEG6 [1] phi from main::@3 to main::@1
-  //SEG7 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
-  //SEG8 main::@1
+  //SEG7 [1] phi from main::@3 to main::@1
+  //SEG8 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG9 main::@1
   b1:
-  //SEG9 [2] call nest param-assignment [ main::i#2 ]
+  //SEG10 [2] call nest param-assignment [ main::i#2 ]
     jsr nest
-  //SEG10 main::@3
-  //SEG11 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
+  //SEG11 main::@3
+  //SEG12 [3] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 ] -- yby=_dec_yby 
     dey
-  //SEG12 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
+  //SEG13 [4] if((byte) main::i#1>(byte) 0) goto main::@1 [ main::i#1 ] -- yby_gt_0_then_la1 
     cpy #$0
     bne b1
-  //SEG13 main::@return
-  //SEG14 [5] return  [ ]
+  //SEG14 main::@return
+  //SEG15 [5] return  [ ]
     rts
 }
-//SEG15 nest
+//SEG16 nest
 nest: {
-  //SEG16 [6] phi from nest to nest::@1
-  //SEG17 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
+  //SEG17 [6] phi from nest to nest::@1
+  //SEG18 [6] phi (byte) nest::j#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG18 [6] phi from nest::@1 to nest::@1
-  //SEG19 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
-  //SEG20 nest::@1
+  //SEG19 [6] phi from nest::@1 to nest::@1
+  //SEG20 [6] phi (byte) nest::j#2 = (byte) nest::j#1 -- register_copy 
+  //SEG21 nest::@1
   b1:
-  //SEG21 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
+  //SEG22 [7] *((word) 1024) ← (byte) nest::j#2 [ main::i#2 nest::j#2 ] -- _star_cowo1=xby 
     stx $400
-  //SEG22 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
+  //SEG23 [8] (byte) nest::j#1 ← -- (byte) nest::j#2 [ main::i#2 nest::j#1 ] -- xby=_dec_xby 
     dex
-  //SEG23 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
+  //SEG24 [9] if((byte) nest::j#1>(byte) 0) goto nest::@1 [ main::i#2 nest::j#1 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b1
-  //SEG24 nest::@return
-  //SEG25 [10] return  [ main::i#2 ]
+  //SEG25 nest::@return
+  //SEG26 [10] return  [ main::i#2 ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/loopnest2.asm

@@ -1,23 +1,26 @@
   jsr main
 main: {
+    .label j = 3
+    .label i = 2
     lda #$64
-    sta $2
+    sta i
   b1:
     lda #$64
-    sta $3
+    sta j
   b2:
     jsr nest1
-    dec $3
-    lda $3
+    dec j
+    lda j
     bne b2
-    dec $2
-    lda $2
+    dec i
+    lda i
     bne b1
     rts
 }
 nest1: {
+    .label i = 4
     lda #$64
-    sta $4
+    sta i
   b1:
     lda #$64
   b2:
@@ -26,8 +29,8 @@ nest1: {
     sbc #$1
     cmp #$0
     bne b2
-    dec $4
-    lda $4
+    dec i
+    lda i
     bne b1
     rts
 }

src/main/java/dk/camelot64/kickc/test/ref/loopnest2.sym

@@ -8,11 +8,11 @@
 (label) main::@5
 (label) main::@return
 (byte) main::i
-(byte) main::i#1 zp byte:2 16.5
-(byte) main::i#2 zp byte:2 1.0476190476190477
+(byte) main::i#1 zp ZP_BYTE:2 i 16.5
+(byte) main::i#2 zp ZP_BYTE:2 i 1.0476190476190477
 (byte) main::j
-(byte) main::j#1 zp byte:3 151.5
-(byte) main::j#2 zp byte:3 11.222222222222221
+(byte) main::j#1 zp ZP_BYTE:3 j 151.5
+(byte) main::j#2 zp ZP_BYTE:3 j 11.222222222222221
 (void()) nest1()
 (label) nest1::@1
 (label) nest1::@2
@@ -20,8 +20,8 @@
 (label) nest1::@5
 (label) nest1::@return
 (byte) nest1::i
-(byte) nest1::i#1 zp byte:4 1501.5
-(byte) nest1::i#2 zp byte:4 154.0
+(byte) nest1::i#1 zp ZP_BYTE:4 i 1501.5
+(byte) nest1::i#2 zp ZP_BYTE:4 i 154.0
 (byte) nest1::j
 (byte) nest1::j#1 reg byte a 15001.5
 (byte) nest1::j#2 reg byte a 2000.2
@@ -37,9 +37,9 @@
 (byte) nest2::j#1 reg byte y 1500001.5
 (byte) nest2::j#2 reg byte y 1500001.5
 
-zp byte:2 [ main::i#2 main::i#1 ]
-zp byte:3 [ main::j#2 main::j#1 ]
-zp byte:4 [ nest1::i#2 nest1::i#1 ]
+zp ZP_BYTE:2 i [ main::i#2 main::i#1 ]
+zp ZP_BYTE:3 j [ main::j#2 main::j#1 ]
+zp ZP_BYTE:4 i [ nest1::i#2 nest1::i#1 ]
 reg byte a [ nest1::j#2 nest1::j#1 ]
 reg byte x [ nest2::i#2 nest2::i#1 ]
 reg byte y [ nest2::j#2 nest2::j#1 ]

src/main/java/dk/camelot64/kickc/test/ref/loopsplit.log

@@ -614,73 +614,76 @@ Initial phi equivalence classes
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
 [ main::s#3 main::s#1 main::s#2 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
-Allocated zp byte:3 [ main::s#3 main::s#1 main::s#2 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:3 s#3 [ main::s#3 main::s#1 main::s#2 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label i = 2
+    .label s = 3
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::s#3 = (byte) 0 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::s#3 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $3
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
+    sta s
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 100 -- zpby1=coby1 
     lda #$64
-    sta $2
+    sta i
     jmp b1
-  //SEG7 main::@1
+  //SEG8 main::@1
   b1:
-  //SEG8 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- zpby1=_dec_zpby1 
-    dec $2
-  //SEG9 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- zpby1_gt_0_then_la1 
-    lda $2
+  //SEG9 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- zpby1=_dec_zpby1 
+    dec i
+  //SEG10 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- zpby1_gt_0_then_la1 
+    lda i
     bne b2
     jmp breturn
-  //SEG10 main::@return
+  //SEG11 main::@return
   breturn:
-  //SEG11 [4] return  [ ]
+  //SEG12 [4] return  [ ]
     rts
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- zpby1_le_coby1_then_la1 
-    lda $2
+  //SEG14 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- zpby1_le_coby1_then_la1 
+    lda i
     cmp #$32
     bcc b4
     beq b4
     jmp b8
-  //SEG14 main::@8
+  //SEG15 main::@8
   b8:
-  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_inc_zpby1 
-    inc $3
-  //SEG16 [1] phi from main::@8 to main::@1
+  //SEG16 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- zpby1=_inc_zpby1 
+    inc s
+  //SEG17 [1] phi from main::@8 to main::@1
   b1_from_b8:
-  //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
-  //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG18 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
+  //SEG19 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG19 main::@4
+  //SEG20 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- zpby1=_dec_zpby1 
-    dec $3
-  //SEG21 [1] phi from main::@4 to main::@1
+  //SEG21 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- zpby1=_dec_zpby1 
+    dec s
+  //SEG22 [1] phi from main::@4 to main::@1
   b1_from_b4:
-  //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG23 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
+  //SEG24 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ main::s#3 main::s#1 main::s#2 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 s [ main::s#3 main::s#1 main::s#2 ] : zp ZP_BYTE:3 s , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] 55: zp byte:3 [ main::s#3 main::s#1 main::s#2 ] 44: zp byte:2 [ main::i#2 main::i#1 ] 
+Uplift Scope [main] 55: zp ZP_BYTE:3 s [ main::s#3 main::s#1 main::s#2 ] 44: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 380 combination reg byte y [ main::s#3 main::s#1 main::s#2 ] reg byte x [ main::i#2 main::i#1 ] 
@@ -691,54 +694,55 @@ Removing instruction jmp breturn
 Removing instruction jmp b8
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG6 [1] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
     ldy #$0
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG7 main::@1
+  //SEG8 main::@1
   b1:
-  //SEG8 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- xby=_dec_xby 
+  //SEG9 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- xby=_dec_xby 
     dex
-  //SEG9 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- xby_gt_0_then_la1 
+  //SEG10 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b2
-  //SEG10 main::@return
+  //SEG11 main::@return
   breturn:
-  //SEG11 [4] return  [ ]
+  //SEG12 [4] return  [ ]
     rts
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
     cpx #$32
     bcc b4
     beq b4
-  //SEG14 main::@8
+  //SEG15 main::@8
   b8:
-  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
+  //SEG16 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG16 [1] phi from main::@8 to main::@1
+  //SEG17 [1] phi from main::@8 to main::@1
   b1_from_b8:
-  //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
-  //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG18 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
+  //SEG19 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG19 main::@4
+  //SEG20 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
+  //SEG21 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
     dey
-  //SEG21 [1] phi from main::@4 to main::@1
+  //SEG22 [1] phi from main::@4 to main::@1
   b1_from_b4:
-  //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG23 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
+  //SEG24 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 
@@ -751,47 +755,48 @@ Removing instruction b1_from_b8:
 Removing instruction b1_from_b4:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
     ldy #$0
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG7 main::@1
+  //SEG8 main::@1
   b1:
-  //SEG8 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- xby=_dec_xby 
+  //SEG9 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- xby=_dec_xby 
     dex
-  //SEG9 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- xby_gt_0_then_la1 
+  //SEG10 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b2
-  //SEG10 main::@return
-  //SEG11 [4] return  [ ]
+  //SEG11 main::@return
+  //SEG12 [4] return  [ ]
     rts
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
     cpx #$32
     bcc b4
     beq b4
-  //SEG14 main::@8
-  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
+  //SEG15 main::@8
+  //SEG16 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG16 [1] phi from main::@8 to main::@1
-  //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
-  //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG17 [1] phi from main::@8 to main::@1
+  //SEG18 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
+  //SEG19 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG19 main::@4
+  //SEG20 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
+  //SEG21 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
     dey
-  //SEG21 [1] phi from main::@4 to main::@1
-  //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG22 [1] phi from main::@4 to main::@1
+  //SEG23 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
+  //SEG24 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 
@@ -816,47 +821,48 @@ reg byte x [ main::i#2 main::i#1 ]
 reg byte y [ main::s#3 main::s#1 main::s#2 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::s#3 = (byte) 0 -- yby=coby1 
     ldy #$0
-  //SEG6 [1] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
+  //SEG7 [1] phi (byte) main::i#2 = (byte) 100 -- xby=coby1 
     ldx #$64
-  //SEG7 main::@1
+  //SEG8 main::@1
   b1:
-  //SEG8 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- xby=_dec_xby 
+  //SEG9 [2] (byte) main::i#1 ← -- (byte) main::i#2 [ main::i#1 main::s#3 ] -- xby=_dec_xby 
     dex
-  //SEG9 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- xby_gt_0_then_la1 
+  //SEG10 [3] if((byte) main::i#1>(byte) 0) goto main::@2 [ main::i#1 main::s#3 ] -- xby_gt_0_then_la1 
     cpx #$0
     bne b2
-  //SEG10 main::@return
-  //SEG11 [4] return  [ ]
+  //SEG11 main::@return
+  //SEG12 [4] return  [ ]
     rts
-  //SEG12 main::@2
+  //SEG13 main::@2
   b2:
-  //SEG13 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
+  //SEG14 [5] if((byte) main::i#1<=(byte) 50) goto main::@4 [ main::i#1 main::s#3 ] -- xby_le_coby1_then_la1 
     cpx #$32
     bcc b4
     beq b4
-  //SEG14 main::@8
-  //SEG15 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
+  //SEG15 main::@8
+  //SEG16 [6] (byte) main::s#2 ← ++ (byte) main::s#3 [ main::i#1 main::s#2 ] -- yby=_inc_yby 
     iny
-  //SEG16 [1] phi from main::@8 to main::@1
-  //SEG17 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
-  //SEG18 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG17 [1] phi from main::@8 to main::@1
+  //SEG18 [1] phi (byte) main::s#3 = (byte) main::s#2 -- register_copy 
+  //SEG19 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
-  //SEG19 main::@4
+  //SEG20 main::@4
   b4:
-  //SEG20 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
+  //SEG21 [7] (byte) main::s#1 ← -- (byte) main::s#3 [ main::i#1 main::s#1 ] -- yby=_dec_yby 
     dey
-  //SEG21 [1] phi from main::@4 to main::@1
-  //SEG22 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
-  //SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG22 [1] phi from main::@4 to main::@1
+  //SEG23 [1] phi (byte) main::s#3 = (byte) main::s#1 -- register_copy 
+  //SEG24 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 

src/main/java/dk/camelot64/kickc/test/ref/minus.log

@@ -332,81 +332,85 @@ Added variable $1 to zero page equivalence class [ $1 ]
 Complete equivalence classes
 [ i#2 i#1 ]
 [ $1 ]
-Allocated zp byte:2 [ i#2 i#1 ]
-Allocated zp byte:3 [ $1 ]
+Allocated zp ZP_BYTE:2 i#2 [ i#2 i#1 ]
+Allocated zp ZP_BYTE:3 $1 [ $1 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+  .label $1 = 3
+  .label i = 2
+//SEG1 @begin
 bbegin:
-//SEG1 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1
 b1_from_bbegin:
-//SEG2 [0] phi (byte) i#2 = (byte) 5 -- zpby1=coby1 
+//SEG3 [0] phi (byte) i#2 = (byte) 5 -- zpby1=coby1 
   lda #$5
-  sta $2
+  sta i
   jmp b1
-//SEG3 [0] phi from @1 to @1
+//SEG4 [0] phi from @1 to @1
 b1_from_b1:
-//SEG4 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
   jmp b1
-//SEG5 @1
+//SEG6 @1
 b1:
-//SEG6 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- zpby1=zpby2_plus_coby1 
-  lda $2
+//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- zpby1=zpby2_plus_coby1 
+  lda i
   clc
   adc #$4
-  sta $3
-//SEG7 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_zpby1=zpby2 
-  lda $3
-  ldx $2
+  sta $1
+//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_zpby1=zpby2 
+  lda $1
+  ldx i
   sta $1100,x
-//SEG8 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- zpby1=zpby1_plus_1 
-  inc $2
-//SEG9 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- zpby1_lt_coby1_then_la1 
-  lda $2
+//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- zpby1=zpby1_plus_1 
+  inc i
+//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- zpby1_lt_coby1_then_la1 
+  lda i
   cmp #$a
   bcc b1_from_b1
   jmp bend
-//SEG10 @end
+//SEG11 @end
 bend:
 
 Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] always clobbers reg byte a 
-Removing always clobbered register reg byte a as potential for zp byte:2 [ i#2 i#1 ]
+Removing always clobbered register reg byte a as potential for zp ZP_BYTE:2 i [ i#2 i#1 ]
 Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] always clobbers reg byte a 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ $1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ i#2 i#1 ] : zp ZP_BYTE:2 i , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 $1 [ $1 ] : zp ZP_BYTE:3 $1 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 31.17: zp byte:2 [ i#2 i#1 ] 22: zp byte:3 [ $1 ] 
+Uplift Scope [] 31.17: zp ZP_BYTE:2 i [ i#2 i#1 ] 22: zp ZP_BYTE:3 $1 [ $1 ] 
 
 Uplifting [] best 285 combination reg byte x [ i#2 i#1 ] reg byte a [ $1 ] 
 Removing instruction jmp b1
 Removing instruction jmp bend
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] phi from @begin to @1
+//SEG2 [0] phi from @begin to @1
 b1_from_bbegin:
-//SEG2 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
+//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
   ldx #$5
   jmp b1
-//SEG3 [0] phi from @1 to @1
+//SEG4 [0] phi from @1 to @1
 b1_from_b1:
-//SEG4 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG5 @1
+//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 @1
 b1:
-//SEG6 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
+//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
   txa
   clc
   adc #$4
-//SEG7 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
+//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
   sta $1100,x
-//SEG8 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
+//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
   inx
-//SEG9 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
+//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
   cpx #$a
   bcc b1_from_b1
-//SEG10 @end
+//SEG11 @end
 bend:
 
 Replacing label b1_from_b1 with b1
@@ -414,79 +418,82 @@ Removing instruction b1_from_bbegin:
 Removing instruction b1_from_b1:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
   ldx #$5
   jmp b1
-//SEG3 [0] phi from @1 to @1
-//SEG4 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG5 @1
+//SEG4 [0] phi from @1 to @1
+//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 @1
 b1:
-//SEG6 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
+//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
   txa
   clc
   adc #$4
-//SEG7 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
+//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
   sta $1100,x
-//SEG8 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
+//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
   inx
-//SEG9 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
+//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
   cpx #$a
   bcc b1
-//SEG10 @end
+//SEG11 @end
 bend:
 
 Removing instruction bbegin:
 Removing instruction bend:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
   ldx #$5
   jmp b1
-//SEG3 [0] phi from @1 to @1
-//SEG4 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG5 @1
+//SEG4 [0] phi from @1 to @1
+//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 @1
 b1:
-//SEG6 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
+//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
   txa
   clc
   adc #$4
-//SEG7 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
+//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
   sta $1100,x
-//SEG8 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
+//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
   inx
-//SEG9 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
+//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
   cpx #$a
   bcc b1
-//SEG10 @end
+//SEG11 @end
 
 Removing instruction jmp b1
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
   ldx #$5
-//SEG3 [0] phi from @1 to @1
-//SEG4 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG5 @1
+//SEG4 [0] phi from @1 to @1
+//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 @1
 b1:
-//SEG6 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
+//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
   txa
   clc
   adc #$4
-//SEG7 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
+//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
   sta $1100,x
-//SEG8 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
+//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
   inx
-//SEG9 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
+//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
   cpx #$a
   bcc b1
-//SEG10 @end
+//SEG11 @end
 
 FINAL SYMBOL TABLE
 (byte~) $1 reg byte a 22.0
@@ -502,24 +509,25 @@ reg byte x [ i#2 i#1 ]
 reg byte a [ $1 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] phi from @begin to @1
-//SEG2 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] phi from @begin to @1
+//SEG3 [0] phi (byte) i#2 = (byte) 5 -- xby=coby1 
   ldx #$5
-//SEG3 [0] phi from @1 to @1
-//SEG4 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
-//SEG5 @1
+//SEG4 [0] phi from @1 to @1
+//SEG5 [0] phi (byte) i#2 = (byte) i#1 -- register_copy 
+//SEG6 @1
 b1:
-//SEG6 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
+//SEG7 [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] -- aby=xby_plus_coby1 
   txa
   clc
   adc #$4
-//SEG7 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
+//SEG8 [2] *((word) 4352 + (byte) i#2) ← (byte~) $1 [ i#2 ] -- cowo1_staridx_xby=aby 
   sta $1100,x
-//SEG8 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
+//SEG9 [3] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1 
   inx
-//SEG9 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
+//SEG10 [4] if((byte) i#1<(byte) 10) goto @1 [ i#1 ] -- xby_lt_coby1_then_la1 
   cpx #$a
   bcc b1
-//SEG10 @end
+//SEG11 @end
 

src/main/java/dk/camelot64/kickc/test/ref/modglobal.asm

@@ -1,5 +1,8 @@
+  .label cnt3 = 2
   jsr main
 main: {
+    lda #$0
+    sta cnt3
     ldy #$0
     ldx #$0
     jsr inccnt
@@ -12,6 +15,7 @@ main: {
 inccnt: {
     inx
     iny
+    inc cnt3
     txa
     rts
 }

src/main/java/dk/camelot64/kickc/test/ref/modglobal.cfg

@@ -3,12 +3,12 @@
   to:@end
 @end: scope:[]  from @begin
 main: scope:[main]  from @begin
-  [1] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 ]
+  [1] call inccnt param-assignment [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
   to:main::@1
 main::@1: scope:[main]  from main
-  [2] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 ]
-  [3] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 ]
-  [4] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 ]
+  [2] (byte~) main::$0 ← (byte) inccnt::return#0 [ main::$0 cnt#1 cnt2#1 cnt3#1 ]
+  [3] *((word) 1024) ← (byte~) main::$0 [ cnt#1 cnt2#1 cnt3#1 ]
+  [4] (byte) cnt#3 ← ++ (byte) cnt#1 [ cnt#3 cnt2#1 cnt3#1 ]
   [5] call inccnt param-assignment [ inccnt::return#0 ]
   to:main::@2
 main::@2: scope:[main]  from main::@1
@@ -19,12 +19,14 @@ main::@return: scope:[main]  from main::@2
   [8] return  [ ]
   to:@return
 inccnt: scope:[inccnt]  from main main::@1
-  [9] (byte) cnt2#11 ← phi( main/(byte) 0 main::@1/(byte) cnt2#1 ) [ cnt#12 cnt2#11 ]
-  [9] (byte) cnt#12 ← phi( main/(byte) 0 main::@1/(byte) cnt#3 ) [ cnt#12 cnt2#11 ]
-  [10] (byte) cnt#1 ← ++ (byte) cnt#12 [ cnt#1 cnt2#11 ]
-  [11] (byte) cnt2#1 ← ++ (byte) cnt2#11 [ cnt#1 cnt2#1 ]
-  [12] (byte) inccnt::return#0 ← (byte) cnt#1 [ inccnt::return#0 cnt#1 cnt2#1 ]
+  [9] (byte) cnt3#11 ← phi( main/(byte) 0 main::@1/(byte) cnt3#1 ) [ cnt#12 cnt2#11 cnt3#11 ]
+  [9] (byte) cnt2#11 ← phi( main/(byte) 0 main::@1/(byte) cnt2#1 ) [ cnt#12 cnt2#11 cnt3#11 ]
+  [9] (byte) cnt#12 ← phi( main/(byte) 0 main::@1/(byte) cnt#3 ) [ cnt#12 cnt2#11 cnt3#11 ]
+  [10] (byte) cnt#1 ← ++ (byte) cnt#12 [ cnt#1 cnt2#11 cnt3#11 ]
+  [11] (byte) cnt2#1 ← ++ (byte) cnt2#11 [ cnt#1 cnt2#1 cnt3#11 ]
+  [12] (byte) cnt3#1 ← ++ (byte) cnt3#11 [ cnt#1 cnt2#1 cnt3#1 ]
+  [13] (byte) inccnt::return#0 ← (byte) cnt#1 [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
   to:inccnt::@return
 inccnt::@return: scope:[inccnt]  from inccnt
-  [13] return  [ inccnt::return#0 cnt#1 cnt2#1 ]
+  [14] return  [ inccnt::return#0 cnt#1 cnt2#1 cnt3#1 ]
   to:@return

src/main/java/dk/camelot64/kickc/test/ref/modglobal.sym

@@ -2,12 +2,15 @@
 (label) @end
 (byte[256]) SCREEN
 (byte) cnt
-(byte) cnt#1 reg byte x 0.8571428571428571
+(byte) cnt#1 reg byte x 0.75
 (byte) cnt#12 reg byte x 4.0
 (byte) cnt#3 reg byte x 4.0
 (byte) cnt2
-(byte) cnt2#1 reg byte y 0.5714285714285714
+(byte) cnt2#1 reg byte y 0.5
 (byte) cnt2#11 reg byte y 2.0
+(byte) cnt3
+(byte) cnt3#1 zp ZP_BYTE:2 cnt3 0.5714285714285714
+(byte) cnt3#11 zp ZP_BYTE:2 cnt3 1.3333333333333333
 (byte()) inccnt()
 (label) inccnt::@return
 (byte) inccnt::return
@@ -21,6 +24,7 @@
 
 reg byte x [ cnt#12 cnt#3 ]
 reg byte y [ cnt2#11 cnt2#1 ]
+zp ZP_BYTE:2 cnt3 [ cnt3#11 cnt3#1 ]
 reg byte a [ main::$0 ]
 reg byte a [ main::$1 ]
 reg byte x [ cnt#1 ]

src/main/java/dk/camelot64/kickc/test/ref/modglobalmin.log

@@ -603,77 +603,81 @@ Complete equivalence classes
 [ cnt#13 cnt#3 ]
 [ cnt#1 ]
 [ cnt#10 ]
-Allocated zp byte:2 [ cnt#13 cnt#3 ]
-Allocated zp byte:3 [ cnt#1 ]
-Allocated zp byte:4 [ cnt#10 ]
+Allocated zp ZP_BYTE:2 cnt#13 [ cnt#13 cnt#3 ]
+Allocated zp ZP_BYTE:3 cnt#1 [ cnt#1 ]
+Allocated zp ZP_BYTE:4 cnt#10 [ cnt#10 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+  .label cnt = 3
+  .label cnt#13 = 2
+  .label cnt#10 = 4
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] call inccnt param-assignment [ cnt#10 ]
-  //SEG5 [8] phi from main to inccnt
+  //SEG5 [1] call inccnt param-assignment [ cnt#10 ]
+  //SEG6 [8] phi from main to inccnt
   inccnt_from_main:
-  //SEG6 [8] phi (byte) cnt#13 = (byte) 0 -- zpby1=coby1 
+  //SEG7 [8] phi (byte) cnt#13 = (byte) 0 -- zpby1=coby1 
     lda #$0
-    sta $2
+    sta cnt_13
     jsr inccnt
     jmp b1
-  //SEG7 main::@1
+  //SEG8 main::@1
   b1:
-  //SEG8 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=zpby1 
-    lda $4
+  //SEG9 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=zpby1 
+    lda cnt_10
     sta $400
-  //SEG9 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- zpby1=_inc_zpby2 
-    lda $4
-    sta $2
-    inc $2
-  //SEG10 [4] call inccnt param-assignment [ cnt#10 ]
-  //SEG11 [8] phi from main::@1 to inccnt
+  //SEG10 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- zpby1=_inc_zpby2 
+    lda cnt_10
+    sta cnt_13
+    inc cnt_13
+  //SEG11 [4] call inccnt param-assignment [ cnt#10 ]
+  //SEG12 [8] phi from main::@1 to inccnt
   inccnt_from_b1:
-  //SEG12 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG13 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
     jsr inccnt
     jmp b2
-  //SEG13 main::@2
+  //SEG14 main::@2
   b2:
-  //SEG14 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- zpby1=_inc_zpby2 
-    lda $4
-    sta $3
-    inc $3
-  //SEG15 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=zpby1 
-    lda $3
+  //SEG15 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- zpby1=_inc_zpby2 
+    lda cnt_10
+    sta cnt
+    inc cnt
+  //SEG16 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=zpby1 
+    lda cnt
     sta $401
     jmp breturn
-  //SEG16 main::@return
+  //SEG17 main::@return
   breturn:
-  //SEG17 [7] return  [ ]
+  //SEG18 [7] return  [ ]
     rts
 }
-//SEG18 inccnt
+//SEG19 inccnt
 inccnt: {
-  //SEG19 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- zpby1=_inc_zpby2 
-    lda $2
-    sta $4
-    inc $4
+  //SEG20 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- zpby1=_inc_zpby2 
+    lda cnt_13
+    sta cnt_10
+    inc cnt_10
     jmp breturn
-  //SEG20 inccnt::@return
+  //SEG21 inccnt::@return
   breturn:
-  //SEG21 [10] return  [ cnt#10 ]
+  //SEG22 [10] return  [ cnt#10 ]
     rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ cnt#13 cnt#3 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ cnt#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:4 [ cnt#10 ] : zp byte:4 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 cnt#13 [ cnt#13 cnt#3 ] : zp ZP_BYTE:2 cnt#13 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 cnt [ cnt#1 ] : zp ZP_BYTE:3 cnt , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:4 cnt#10 [ cnt#10 ] : zp ZP_BYTE:4 cnt#10 , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] 8: zp byte:2 [ cnt#13 cnt#3 ] 4: zp byte:3 [ cnt#1 ] 1.6: zp byte:4 [ cnt#10 ] 
+Uplift Scope [] 8: zp ZP_BYTE:2 cnt#13 [ cnt#13 cnt#3 ] 4: zp ZP_BYTE:3 cnt [ cnt#1 ] 1.6: zp ZP_BYTE:4 cnt#10 [ cnt#10 ] 
 Uplift Scope [main] 
 Uplift Scope [inccnt] 
 
@@ -687,49 +691,50 @@ Removing instruction jmp breturn
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] call inccnt param-assignment [ cnt#10 ]
-  //SEG5 [8] phi from main to inccnt
+  //SEG5 [1] call inccnt param-assignment [ cnt#10 ]
+  //SEG6 [8] phi from main to inccnt
   inccnt_from_main:
-  //SEG6 [8] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG7 [8] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
     ldx #$0
     jsr inccnt
-  //SEG7 main::@1
+  //SEG8 main::@1
   b1:
-  //SEG8 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby 
+  //SEG9 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby 
     stx $400
-  //SEG9 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
+  //SEG10 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
-  //SEG10 [4] call inccnt param-assignment [ cnt#10 ]
-  //SEG11 [8] phi from main::@1 to inccnt
+  //SEG11 [4] call inccnt param-assignment [ cnt#10 ]
+  //SEG12 [8] phi from main::@1 to inccnt
   inccnt_from_b1:
-  //SEG12 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG13 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
     jsr inccnt
-  //SEG13 main::@2
+  //SEG14 main::@2
   b2:
-  //SEG14 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
+  //SEG15 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby 
+  //SEG16 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby 
     stx $401
-  //SEG16 main::@return
+  //SEG17 main::@return
   breturn:
-  //SEG17 [7] return  [ ]
+  //SEG18 [7] return  [ ]
     rts
 }
-//SEG18 inccnt
+//SEG19 inccnt
 inccnt: {
-  //SEG19 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- xby=_inc_xby 
+  //SEG20 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- xby=_inc_xby 
     inx
-  //SEG20 inccnt::@return
+  //SEG21 inccnt::@return
   breturn:
-  //SEG21 [10] return  [ cnt#10 ]
+  //SEG22 [10] return  [ cnt#10 ]
     rts
 }
 
@@ -743,41 +748,42 @@ Removing instruction breturn:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] call inccnt param-assignment [ cnt#10 ]
-  //SEG5 [8] phi from main to inccnt
-  //SEG6 [8] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG5 [1] call inccnt param-assignment [ cnt#10 ]
+  //SEG6 [8] phi from main to inccnt
+  //SEG7 [8] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
     ldx #$0
     jsr inccnt
-  //SEG7 main::@1
-  //SEG8 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby 
+  //SEG8 main::@1
+  //SEG9 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby 
     stx $400
-  //SEG9 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
+  //SEG10 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
-  //SEG10 [4] call inccnt param-assignment [ cnt#10 ]
-  //SEG11 [8] phi from main::@1 to inccnt
-  //SEG12 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG11 [4] call inccnt param-assignment [ cnt#10 ]
+  //SEG12 [8] phi from main::@1 to inccnt
+  //SEG13 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
     jsr inccnt
-  //SEG13 main::@2
-  //SEG14 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
+  //SEG14 main::@2
+  //SEG15 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby 
+  //SEG16 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby 
     stx $401
-  //SEG16 main::@return
-  //SEG17 [7] return  [ ]
+  //SEG17 main::@return
+  //SEG18 [7] return  [ ]
     rts
 }
-//SEG18 inccnt
+//SEG19 inccnt
 inccnt: {
-  //SEG19 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- xby=_inc_xby 
+  //SEG20 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- xby=_inc_xby 
     inx
-  //SEG20 inccnt::@return
-  //SEG21 [10] return  [ cnt#10 ]
+  //SEG21 inccnt::@return
+  //SEG22 [10] return  [ cnt#10 ]
     rts
 }
 
@@ -802,41 +808,42 @@ reg byte x [ cnt#1 ]
 reg byte x [ cnt#10 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] call inccnt param-assignment [ cnt#10 ]
-  //SEG5 [8] phi from main to inccnt
-  //SEG6 [8] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
+  //SEG5 [1] call inccnt param-assignment [ cnt#10 ]
+  //SEG6 [8] phi from main to inccnt
+  //SEG7 [8] phi (byte) cnt#13 = (byte) 0 -- xby=coby1 
     ldx #$0
     jsr inccnt
-  //SEG7 main::@1
-  //SEG8 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby 
+  //SEG8 main::@1
+  //SEG9 [2] *((word) 1024) ← (byte) cnt#10 [ cnt#10 ] -- _star_cowo1=xby 
     stx $400
-  //SEG9 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
+  //SEG10 [3] (byte) cnt#3 ← ++ (byte) cnt#10 [ cnt#3 ] -- xby=_inc_xby 
     inx
-  //SEG10 [4] call inccnt param-assignment [ cnt#10 ]
-  //SEG11 [8] phi from main::@1 to inccnt
-  //SEG12 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
+  //SEG11 [4] call inccnt param-assignment [ cnt#10 ]
+  //SEG12 [8] phi from main::@1 to inccnt
+  //SEG13 [8] phi (byte) cnt#13 = (byte) cnt#3 -- register_copy 
     jsr inccnt
-  //SEG13 main::@2
-  //SEG14 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
+  //SEG14 main::@2
+  //SEG15 [5] (byte) cnt#1 ← ++ (byte) cnt#10 [ cnt#1 ] -- xby=_inc_xby 
     inx
-  //SEG15 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby 
+  //SEG16 [6] *((word) 1025) ← (byte) cnt#1 [ ] -- _star_cowo1=xby 
     stx $401
-  //SEG16 main::@return
-  //SEG17 [7] return  [ ]
+  //SEG17 main::@return
+  //SEG18 [7] return  [ ]
     rts
 }
-//SEG18 inccnt
+//SEG19 inccnt
 inccnt: {
-  //SEG19 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- xby=_inc_xby 
+  //SEG20 [9] (byte) cnt#10 ← ++ (byte) cnt#13 [ cnt#10 ] -- xby=_inc_xby 
     inx
-  //SEG20 inccnt::@return
-  //SEG21 [10] return  [ cnt#10 ]
+  //SEG21 inccnt::@return
+  //SEG22 [10] return  [ cnt#10 ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/ptrtest.asm

@@ -7,10 +7,11 @@ main: {
     rts
 }
 lvaluevar: {
+    .label screen = 2
     lda #<$400
-    sta $2
+    sta screen
     lda #>$400
-    sta $2+$1
+    sta screen+$1
     ldx #$2
   b1:
     cpx #$a
@@ -19,19 +20,20 @@ lvaluevar: {
   b2:
     ldy #$0
     lda #$4
-    sta ($2),y
-    inc $2
+    sta (screen),y
+    inc screen
     bne !+
-    inc $2+$1
+    inc screen+$1
   !:
     inx
     jmp b1
 }
 rvaluevar: {
+    .label screen = 2
     lda #<$400
-    sta $2
+    sta lvaluevar.screen
     lda #>$400
-    sta $2+$1
+    sta lvaluevar.screen+$1
     ldx #$2
   b1:
     cpx #$a
@@ -39,10 +41,10 @@ rvaluevar: {
     rts
   b2:
     ldy #$0
-    lda ($2),y
-    inc $2
+    lda (lvaluevar.screen),y
+    inc lvaluevar.screen
     bne !+
-    inc $2+$1
+    inc lvaluevar.screen+$1
   !:
     inx
     jmp b1

src/main/java/dk/camelot64/kickc/test/ref/ptrtest.sym

@@ -17,8 +17,8 @@
 (byte) lvaluevar::i#1 reg byte x 22.0
 (byte) lvaluevar::i#2 reg byte x 8.25
 (byte*) lvaluevar::screen
-(byte*) lvaluevar::screen#1 zp ptr byte:2 11.0
-(byte*) lvaluevar::screen#2 zp ptr byte:2 11.0
+(byte*) lvaluevar::screen#1 zp ZP_PTR_BYTE:2 screen 11.0
+(byte*) lvaluevar::screen#2 zp ZP_PTR_BYTE:2 screen 11.0
 (void()) main()
 (label) main::@1
 (label) main::@2
@@ -46,11 +46,11 @@
 (byte) rvaluevar::i#1 reg byte x 22.0
 (byte) rvaluevar::i#2 reg byte x 8.25
 (byte*) rvaluevar::screen
-(byte*) rvaluevar::screen#1 zp ptr byte:2 11.0
-(byte*) rvaluevar::screen#2 zp ptr byte:2 11.0
+(byte*) rvaluevar::screen#1 zp ZP_PTR_BYTE:2 screen 11.0
+(byte*) rvaluevar::screen#2 zp ZP_PTR_BYTE:2 screen 11.0
 
 reg byte x [ lvaluevar::i#2 lvaluevar::i#1 ]
-zp ptr byte:2 [ lvaluevar::screen#2 lvaluevar::screen#1 rvaluevar::screen#2 rvaluevar::screen#1 ]
+zp ZP_PTR_BYTE:2 screen [ lvaluevar::screen#2 lvaluevar::screen#1 rvaluevar::screen#2 rvaluevar::screen#1 ]
 reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ]
 reg byte x [ rvalue::i#2 rvalue::i#1 ]
 reg byte x [ lvalue::i#2 lvalue::i#1 ]

src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.log

@@ -484,55 +484,58 @@ Added variable main::b#0 to zero page equivalence class [ main::b#0 ]
 Complete equivalence classes
 [ main::i#2 main::i#1 ]
 [ main::b#0 ]
-Allocated zp byte:2 [ main::i#2 main::i#1 ]
-Allocated zp byte:3 [ main::b#0 ]
+Allocated zp ZP_BYTE:2 i#2 [ main::i#2 main::i#1 ]
+Allocated zp ZP_BYTE:3 b#0 [ main::b#0 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+    .label b = 3
+    .label i = 2
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- zpby1=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 2 -- zpby1=coby1 
     lda #$2
-    sta $2
+    sta i
     jmp b1
-  //SEG6 main::@1
+  //SEG7 main::@1
   b1:
-  //SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- zpby1_lt_coby1_then_la1 
-    lda $2
+  //SEG8 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- zpby1_lt_coby1_then_la1 
+    lda i
     cmp #$a
     bcc b2
     jmp breturn
-  //SEG8 main::@return
+  //SEG9 main::@return
   breturn:
-  //SEG9 [3] return  [ ]
+  //SEG10 [3] return  [ ]
     rts
-  //SEG10 main::@2
+  //SEG11 main::@2
   b2:
-  //SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- zpby1=cowo1_staridx_zpby2 
-    ldx $2
+  //SEG12 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- zpby1=cowo1_staridx_zpby2 
+    ldx i
     lda $400,x
-    sta $3
-  //SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
-    inc $2
-  //SEG13 [1] phi from main::@2 to main::@1
+    sta b
+  //SEG13 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
+    inc i
+  //SEG14 [1] phi from main::@2 to main::@1
   b1_from_b2:
-  //SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG15 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ main::b#0 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 i , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 b [ main::b#0 ] : zp ZP_BYTE:3 b , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [main] ∞: zp byte:3 [ main::b#0 ] 36.67: zp byte:2 [ main::i#2 main::i#1 ] 
+Uplift Scope [main] ∞: zp ZP_BYTE:3 b [ main::b#0 ] 36.67: zp ZP_BYTE:2 i [ main::i#2 main::i#1 ] 
 Uplift Scope [] 
 
 Uplifting [main] best 235 combination reg byte a [ main::b#0 ] reg byte x [ main::i#2 main::i#1 ] 
@@ -542,36 +545,37 @@ Removing instruction jmp b1
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
+  //SEG5 [1] phi from main to main::@1
   b1_from_main:
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
     ldx #$2
-  //SEG6 main::@1
+  //SEG7 main::@1
   b1:
-  //SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG8 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
     cpx #$a
     bcc b2
-  //SEG8 main::@return
+  //SEG9 main::@return
   breturn:
-  //SEG9 [3] return  [ ]
+  //SEG10 [3] return  [ ]
     rts
-  //SEG10 main::@2
+  //SEG11 main::@2
   b2:
-  //SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby 
     lda $400,x
-  //SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG13 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG13 [1] phi from main::@2 to main::@1
+  //SEG14 [1] phi from main::@2 to main::@1
   b1_from_b2:
-  //SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG15 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 
@@ -582,31 +586,32 @@ Removing instruction breturn:
 Removing instruction b1_from_b2:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
     ldx #$2
-  //SEG6 main::@1
+  //SEG7 main::@1
   b1:
-  //SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG8 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
     cpx #$a
     bcc b2
-  //SEG8 main::@return
-  //SEG9 [3] return  [ ]
+  //SEG9 main::@return
+  //SEG10 [3] return  [ ]
     rts
-  //SEG10 main::@2
+  //SEG11 main::@2
   b2:
-  //SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby 
     lda $400,x
-  //SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG13 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG13 [1] phi from main::@2 to main::@1
-  //SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG14 [1] phi from main::@2 to main::@1
+  //SEG15 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 
@@ -628,31 +633,32 @@ reg byte x [ main::i#2 main::i#1 ]
 reg byte a [ main::b#0 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] phi from main to main::@1
-  //SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
+  //SEG5 [1] phi from main to main::@1
+  //SEG6 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1 
     ldx #$2
-  //SEG6 main::@1
+  //SEG7 main::@1
   b1:
-  //SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
+  //SEG8 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1 
     cpx #$a
     bcc b2
-  //SEG8 main::@return
-  //SEG9 [3] return  [ ]
+  //SEG9 main::@return
+  //SEG10 [3] return  [ ]
     rts
-  //SEG10 main::@2
+  //SEG11 main::@2
   b2:
-  //SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby 
+  //SEG12 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby 
     lda $400,x
-  //SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
+  //SEG13 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
     inx
-  //SEG13 [1] phi from main::@2 to main::@1
-  //SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
+  //SEG14 [1] phi from main::@2 to main::@1
+  //SEG15 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
     jmp b1
 }
 

src/main/java/dk/camelot64/kickc/test/ref/summin.asm

@@ -1,7 +1,8 @@
+  .label s1 = 2
   lda #$2
   ldy #$1
   jsr sum
-  sta $2
+  sta s1
   lda #$4
   ldy #$3
   jsr sum
@@ -9,12 +10,13 @@
   lda #$d
   ldy #$9
   jsr sum
-  sta $3
+  tay
   txa
   clc
-  adc $2
+  adc s1
+  sty $ff
   clc
-  adc $3
+  adc $ff
 sum: {
     sty $ff
     clc

src/main/java/dk/camelot64/kickc/test/ref/summin.log

@@ -558,110 +558,118 @@ Complete equivalence classes
 [ $3 ]
 [ s4#0 ]
 [ sum::return#0 ]
-Allocated zp byte:2 [ sum::a#3 ]
-Allocated zp byte:3 [ sum::b#3 ]
-Allocated zp byte:4 [ s1#0 ]
-Allocated zp byte:5 [ s2#0 ]
-Allocated zp byte:6 [ s3#0 ]
-Allocated zp byte:7 [ $3 ]
-Allocated zp byte:8 [ s4#0 ]
-Allocated zp byte:9 [ sum::return#0 ]
+Allocated zp ZP_BYTE:2 a#3 [ sum::a#3 ]
+Allocated zp ZP_BYTE:3 b#3 [ sum::b#3 ]
+Allocated zp ZP_BYTE:4 s1#0 [ s1#0 ]
+Allocated zp ZP_BYTE:5 s2#0 [ s2#0 ]
+Allocated zp ZP_BYTE:6 s3#0 [ s3#0 ]
+Allocated zp ZP_BYTE:7 $3 [ $3 ]
+Allocated zp ZP_BYTE:8 s4#0 [ s4#0 ]
+Allocated zp ZP_BYTE:9 return#0 [ sum::return#0 ]
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+  .label $3 = 7
+  .label s1 = 4
+  .label s2 = 5
+  .label s3 = 6
+  .label s4 = 8
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call sum param-assignment [ sum::return#0 ]
-//SEG2 [8] phi from @begin to sum
+//SEG2 [0] call sum param-assignment [ sum::return#0 ]
+//SEG3 [8] phi from @begin to sum
 sum_from_bbegin:
-//SEG3 [8] phi (byte) sum::b#3 = (byte) 2 -- zpby1=coby1 
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- zpby1=coby1 
   lda #$2
-  sta $3
-//SEG4 [8] phi (byte) sum::a#3 = (byte) 1 -- zpby1=coby1 
+  sta b
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- zpby1=coby1 
   lda #$1
-  sta $2
+  sta a
   jsr sum
   jmp b2
-//SEG5 @2
+//SEG6 @2
 b2:
-//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=zpby2 
-  lda $9
-  sta $4
-//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
-//SEG8 [8] phi from @2 to sum
+//SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=zpby2 
+  lda sum.return
+  sta s1
+//SEG8 [2] call sum param-assignment [ sum::return#0 s1#0 ]
+//SEG9 [8] phi from @2 to sum
 sum_from_b2:
-//SEG9 [8] phi (byte) sum::b#3 = (byte) 4 -- zpby1=coby1 
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- zpby1=coby1 
   lda #$4
-  sta $3
-//SEG10 [8] phi (byte) sum::a#3 = (byte) 3 -- zpby1=coby1 
+  sta b
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- zpby1=coby1 
   lda #$3
-  sta $2
+  sta a
   jsr sum
   jmp b3
-//SEG11 @3
+//SEG12 @3
 b3:
-//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- zpby1=zpby2 
-  lda $9
-  sta $5
-//SEG13 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
-//SEG14 [8] phi from @3 to sum
+//SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- zpby1=zpby2 
+  lda sum.return
+  sta s2
+//SEG14 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
+//SEG15 [8] phi from @3 to sum
 sum_from_b3:
-//SEG15 [8] phi (byte) sum::b#3 = (byte) 13 -- zpby1=coby1 
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- zpby1=coby1 
   lda #$d
-  sta $3
-//SEG16 [8] phi (byte) sum::a#3 = (byte) 9 -- zpby1=coby1 
+  sta b
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- zpby1=coby1 
   lda #$9
-  sta $2
+  sta a
   jsr sum
   jmp b4
-//SEG17 @4
+//SEG18 @4
 b4:
-//SEG18 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- zpby1=zpby2 
-  lda $9
-  sta $6
-//SEG19 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- zpby1=zpby2_plus_zpby3 
-  lda $4
+//SEG19 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- zpby1=zpby2 
+  lda sum.return
+  sta s3
+//SEG20 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- zpby1=zpby2_plus_zpby3 
+  lda s1
   clc
-  adc $5
-  sta $7
-//SEG20 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- zpby1=zpby2_plus_zpby3 
-  lda $7
+  adc s2
+  sta $3
+//SEG21 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- zpby1=zpby2_plus_zpby3 
+  lda $3
   clc
-  adc $6
-  sta $8
+  adc s3
+  sta s4
   jmp bend
-//SEG21 @end
+//SEG22 @end
 bend:
-//SEG22 sum
+//SEG23 sum
 sum: {
-  //SEG23 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- zpby1=zpby2_plus_zpby3 
-    lda $2
+    .label return = 9
+    .label a = 2
+    .label b = 3
+  //SEG24 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- zpby1=zpby2_plus_zpby3 
+    lda a
     clc
-    adc $3
-    sta $9
+    adc b
+    sta return
     jmp breturn
-  //SEG24 sum::@return
+  //SEG25 sum::@return
   breturn:
-  //SEG25 [10] return  [ sum::return#0 s1#0 s2#0 ]
+  //SEG26 [10] return  [ sum::return#0 s1#0 s2#0 ]
     rts
 }
 
 REGISTER UPLIFT POTENTIAL REGISTERS
-Potential registers zp byte:2 [ sum::a#3 ] : zp byte:2 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:3 [ sum::b#3 ] : zp byte:3 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:4 [ s1#0 ] : zp byte:4 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:5 [ s2#0 ] : zp byte:5 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:6 [ s3#0 ] : zp byte:6 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:7 [ $3 ] : zp byte:7 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:8 [ s4#0 ] : zp byte:8 , reg byte a , reg byte x , reg byte y , 
-Potential registers zp byte:9 [ sum::return#0 ] : zp byte:9 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:2 a [ sum::a#3 ] : zp ZP_BYTE:2 a , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:3 b [ sum::b#3 ] : zp ZP_BYTE:3 b , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:4 s1 [ s1#0 ] : zp ZP_BYTE:4 s1 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:5 s2 [ s2#0 ] : zp ZP_BYTE:5 s2 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:6 s3 [ s3#0 ] : zp ZP_BYTE:6 s3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:7 $3 [ $3 ] : zp ZP_BYTE:7 $3 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:8 s4 [ s4#0 ] : zp ZP_BYTE:8 s4 , reg byte a , reg byte x , reg byte y , 
+Potential registers zp ZP_BYTE:9 return [ sum::return#0 ] : zp ZP_BYTE:9 return , reg byte a , reg byte x , reg byte y , 
 
 REGISTER UPLIFT SCOPES
-Uplift Scope [] ∞: zp byte:8 [ s4#0 ] 4: zp byte:7 [ $3 ] 2: zp byte:6 [ s3#0 ] 0.67: zp byte:5 [ s2#0 ] 0.5: zp byte:4 [ s1#0 ] 
-Uplift Scope [sum] 2: zp byte:2 [ sum::a#3 ] 2: zp byte:3 [ sum::b#3 ] 1.6: zp byte:9 [ sum::return#0 ] 
+Uplift Scope [] ∞: zp ZP_BYTE:8 s4 [ s4#0 ] 4: zp ZP_BYTE:7 $3 [ $3 ] 2: zp ZP_BYTE:6 s3 [ s3#0 ] 0.67: zp ZP_BYTE:5 s2 [ s2#0 ] 0.5: zp ZP_BYTE:4 s1 [ s1#0 ] 
+Uplift Scope [sum] 2: zp ZP_BYTE:2 a [ sum::a#3 ] 2: zp ZP_BYTE:3 b [ sum::b#3 ] 1.6: zp ZP_BYTE:9 return [ sum::return#0 ] 
 
-Uplifting [] best 107 combination reg byte a [ s4#0 ] reg byte a [ $3 ] zp byte:6 [ s3#0 ] reg byte x [ s2#0 ] zp byte:4 [ s1#0 ] 
-Uplifting [sum] best 79 combination reg byte y [ sum::a#3 ] reg byte a [ sum::b#3 ] reg byte a [ sum::return#0 ] 
-Allocated (was zp byte:4) zp byte:2 [ s1#0 ]
-Allocated (was zp byte:6) zp byte:3 [ s3#0 ]
+Uplifting [] best 121 combination reg byte a [ s4#0 ] reg byte a [ $3 ] reg byte y [ s3#0 ] reg byte x [ s2#0 ] zp ZP_BYTE:4 s1 [ s1#0 ] 
+Uplifting [sum] best 83 combination reg byte y [ sum::a#3 ] reg byte a [ sum::b#3 ] reg byte a [ sum::return#0 ] 
+Allocated (was zp ZP_BYTE:4 s1) zp ZP_BYTE:2 s1#0 [ s1#0 ]
 Removing instruction jmp b2
 Removing instruction jmp b3
 Removing instruction jmp b4
@@ -669,123 +677,129 @@ Removing instruction jmp bend
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+  .label s1 = 2
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call sum param-assignment [ sum::return#0 ]
-//SEG2 [8] phi from @begin to sum
+//SEG2 [0] call sum param-assignment [ sum::return#0 ]
+//SEG3 [8] phi from @begin to sum
 sum_from_bbegin:
-//SEG3 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
   lda #$2
-//SEG4 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
   ldy #$1
   jsr sum
-//SEG5 @2
+//SEG6 @2
 b2:
-//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
-  sta $2
-//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
-//SEG8 [8] phi from @2 to sum
+//SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
+  sta s1
+//SEG8 [2] call sum param-assignment [ sum::return#0 s1#0 ]
+//SEG9 [8] phi from @2 to sum
 sum_from_b2:
-//SEG9 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
   lda #$4
-//SEG10 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
   ldy #$3
   jsr sum
-//SEG11 @3
+//SEG12 @3
 b3:
-//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
+//SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
-//SEG13 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
-//SEG14 [8] phi from @3 to sum
+//SEG14 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
+//SEG15 [8] phi from @3 to sum
 sum_from_b3:
-//SEG15 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
   lda #$d
-//SEG16 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
   ldy #$9
   jsr sum
-//SEG17 @4
+//SEG18 @4
 b4:
-//SEG18 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- zpby1=aby 
-  sta $3
-//SEG19 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
+//SEG19 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- yby=aby 
+  tay
+//SEG20 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
   txa
   clc
-  adc $2
-//SEG20 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_zpby1 
+  adc s1
+//SEG21 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_yby 
+  sty $ff
   clc
-  adc $3
-//SEG21 @end
+  adc $ff
+//SEG22 @end
 bend:
-//SEG22 sum
+//SEG23 sum
 sum: {
-  //SEG23 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
+  //SEG24 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
     sty $ff
     clc
     adc $ff
-  //SEG24 sum::@return
+  //SEG25 sum::@return
   breturn:
-  //SEG25 [10] return  [ sum::return#0 s1#0 s2#0 ]
+  //SEG26 [10] return  [ sum::return#0 s1#0 s2#0 ]
     rts
 }
 
 Removing instruction sum_from_bbegin:
 Succesful ASM optimization Pass5RedundantLabelElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+  .label s1 = 2
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call sum param-assignment [ sum::return#0 ]
-//SEG2 [8] phi from @begin to sum
-//SEG3 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG2 [0] call sum param-assignment [ sum::return#0 ]
+//SEG3 [8] phi from @begin to sum
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
   lda #$2
-//SEG4 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
   ldy #$1
   jsr sum
-//SEG5 @2
+//SEG6 @2
 b2:
-//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
-  sta $2
-//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
-//SEG8 [8] phi from @2 to sum
+//SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
+  sta s1
+//SEG8 [2] call sum param-assignment [ sum::return#0 s1#0 ]
+//SEG9 [8] phi from @2 to sum
 sum_from_b2:
-//SEG9 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
   lda #$4
-//SEG10 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
   ldy #$3
   jsr sum
-//SEG11 @3
+//SEG12 @3
 b3:
-//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
+//SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
-//SEG13 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
-//SEG14 [8] phi from @3 to sum
+//SEG14 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
+//SEG15 [8] phi from @3 to sum
 sum_from_b3:
-//SEG15 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
   lda #$d
-//SEG16 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
   ldy #$9
   jsr sum
-//SEG17 @4
+//SEG18 @4
 b4:
-//SEG18 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- zpby1=aby 
-  sta $3
-//SEG19 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
+//SEG19 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- yby=aby 
+  tay
+//SEG20 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
   txa
   clc
-  adc $2
-//SEG20 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_zpby1 
+  adc s1
+//SEG21 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_yby 
+  sty $ff
   clc
-  adc $3
-//SEG21 @end
+  adc $ff
+//SEG22 @end
 bend:
-//SEG22 sum
+//SEG23 sum
 sum: {
-  //SEG23 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
+  //SEG24 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
     sty $ff
     clc
     adc $ff
-  //SEG24 sum::@return
+  //SEG25 sum::@return
   breturn:
-  //SEG25 [10] return  [ sum::return#0 s1#0 s2#0 ]
+  //SEG26 [10] return  [ sum::return#0 s1#0 s2#0 ]
     rts
 }
 
@@ -799,53 +813,56 @@ Removing instruction bend:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call sum param-assignment [ sum::return#0 ]
-//SEG2 [8] phi from @begin to sum
-//SEG3 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG0 Global ZP labels
+  .label s1 = 2
+//SEG1 @begin
+//SEG2 [0] call sum param-assignment [ sum::return#0 ]
+//SEG3 [8] phi from @begin to sum
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
   lda #$2
-//SEG4 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
   ldy #$1
   jsr sum
-//SEG5 @2
-//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
-  sta $2
-//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
-//SEG8 [8] phi from @2 to sum
-//SEG9 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG6 @2
+//SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
+  sta s1
+//SEG8 [2] call sum param-assignment [ sum::return#0 s1#0 ]
+//SEG9 [8] phi from @2 to sum
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
   lda #$4
-//SEG10 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
   ldy #$3
   jsr sum
-//SEG11 @3
-//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
+//SEG12 @3
+//SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
-//SEG13 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
-//SEG14 [8] phi from @3 to sum
-//SEG15 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG14 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
+//SEG15 [8] phi from @3 to sum
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
   lda #$d
-//SEG16 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
   ldy #$9
   jsr sum
-//SEG17 @4
-//SEG18 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- zpby1=aby 
-  sta $3
-//SEG19 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
+//SEG18 @4
+//SEG19 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- yby=aby 
+  tay
+//SEG20 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
   txa
   clc
-  adc $2
-//SEG20 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_zpby1 
+  adc s1
+//SEG21 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_yby 
+  sty $ff
   clc
-  adc $3
-//SEG21 @end
-//SEG22 sum
+  adc $ff
+//SEG22 @end
+//SEG23 sum
 sum: {
-  //SEG23 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
+  //SEG24 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
     sty $ff
     clc
     adc $ff
-  //SEG24 sum::@return
-  //SEG25 [10] return  [ sum::return#0 s1#0 s2#0 ]
+  //SEG25 sum::@return
+  //SEG26 [10] return  [ sum::return#0 s1#0 s2#0 ]
     rts
 }
 
@@ -857,11 +874,11 @@ FINAL SYMBOL TABLE
 (label) @begin
 (label) @end
 (byte) s1
-(byte) s1#0 zp byte:2 0.5
+(byte) s1#0 zp ZP_BYTE:2 s1 0.5
 (byte) s2
 (byte) s2#0 reg byte x 0.6666666666666666
 (byte) s3
-(byte) s3#0 zp byte:3 2.0
+(byte) s3#0 reg byte y 2.0
 (byte) s4
 (byte) s4#0 reg byte a Infinity
 (byte()) sum((byte) sum::a , (byte) sum::b)
@@ -875,61 +892,64 @@ FINAL SYMBOL TABLE
 
 reg byte y [ sum::a#3 ]
 reg byte a [ sum::b#3 ]
-zp byte:2 [ s1#0 ]
+zp ZP_BYTE:2 s1 [ s1#0 ]
 reg byte x [ s2#0 ]
-zp byte:3 [ s3#0 ]
+reg byte y [ s3#0 ]
 reg byte a [ $3 ]
 reg byte a [ s4#0 ]
 reg byte a [ sum::return#0 ]
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call sum param-assignment [ sum::return#0 ]
-//SEG2 [8] phi from @begin to sum
-//SEG3 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
+//SEG0 Global ZP labels
+  .label s1 = 2
+//SEG1 @begin
+//SEG2 [0] call sum param-assignment [ sum::return#0 ]
+//SEG3 [8] phi from @begin to sum
+//SEG4 [8] phi (byte) sum::b#3 = (byte) 2 -- aby=coby1 
   lda #$2
-//SEG4 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
+//SEG5 [8] phi (byte) sum::a#3 = (byte) 1 -- yby=coby1 
   ldy #$1
   jsr sum
-//SEG5 @2
-//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
-  sta $2
-//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
-//SEG8 [8] phi from @2 to sum
-//SEG9 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
+//SEG6 @2
+//SEG7 [1] (byte) s1#0 ← (byte) sum::return#0 [ s1#0 ] -- zpby1=aby 
+  sta s1
+//SEG8 [2] call sum param-assignment [ sum::return#0 s1#0 ]
+//SEG9 [8] phi from @2 to sum
+//SEG10 [8] phi (byte) sum::b#3 = (byte) 4 -- aby=coby1 
   lda #$4
-//SEG10 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
+//SEG11 [8] phi (byte) sum::a#3 = (byte) 3 -- yby=coby1 
   ldy #$3
   jsr sum
-//SEG11 @3
-//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
+//SEG12 @3
+//SEG13 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- xby=aby 
   tax
-//SEG13 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
-//SEG14 [8] phi from @3 to sum
-//SEG15 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
+//SEG14 [4] call sum param-assignment [ sum::return#0 s1#0 s2#0 ]
+//SEG15 [8] phi from @3 to sum
+//SEG16 [8] phi (byte) sum::b#3 = (byte) 13 -- aby=coby1 
   lda #$d
-//SEG16 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
+//SEG17 [8] phi (byte) sum::a#3 = (byte) 9 -- yby=coby1 
   ldy #$9
   jsr sum
-//SEG17 @4
-//SEG18 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- zpby1=aby 
-  sta $3
-//SEG19 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
+//SEG18 @4
+//SEG19 [5] (byte) s3#0 ← (byte) sum::return#0 [ s1#0 s2#0 s3#0 ] -- yby=aby 
+  tay
+//SEG20 [6] (byte~) $3 ← (byte) s1#0 + (byte) s2#0 [ $3 s3#0 ] -- aby=zpby1_plus_xby 
   txa
   clc
-  adc $2
-//SEG20 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_zpby1 
+  adc s1
+//SEG21 [7] (byte) s4#0 ← (byte~) $3 + (byte) s3#0 [ ] -- aby=aby_plus_yby 
+  sty $ff
   clc
-  adc $3
-//SEG21 @end
-//SEG22 sum
+  adc $ff
+//SEG22 @end
+//SEG23 sum
 sum: {
-  //SEG23 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
+  //SEG24 [9] (byte) sum::return#0 ← (byte) sum::a#3 + (byte) sum::b#3 [ sum::return#0 s1#0 s2#0 ] -- aby=yby_plus_aby 
     sty $ff
     clc
     adc $ff
-  //SEG24 sum::@return
-  //SEG25 [10] return  [ sum::return#0 s1#0 s2#0 ]
+  //SEG25 sum::@return
+  //SEG26 [10] return  [ sum::return#0 s1#0 s2#0 ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/summin.sym

@@ -5,11 +5,11 @@
 (label) @begin
 (label) @end
 (byte) s1
-(byte) s1#0 zp byte:2 0.5
+(byte) s1#0 zp ZP_BYTE:2 s1 0.5
 (byte) s2
 (byte) s2#0 reg byte x 0.6666666666666666
 (byte) s3
-(byte) s3#0 zp byte:3 2.0
+(byte) s3#0 reg byte y 2.0
 (byte) s4
 (byte) s4#0 reg byte a Infinity
 (byte()) sum((byte) sum::a , (byte) sum::b)
@@ -23,9 +23,9 @@
 
 reg byte y [ sum::a#3 ]
 reg byte a [ sum::b#3 ]
-zp byte:2 [ s1#0 ]
+zp ZP_BYTE:2 s1 [ s1#0 ]
 reg byte x [ s2#0 ]
-zp byte:3 [ s3#0 ]
+reg byte y [ s3#0 ]
 reg byte a [ $3 ]
 reg byte a [ s4#0 ]
 reg byte a [ sum::return#0 ]

src/main/java/dk/camelot64/kickc/test/ref/useglobal.log

@@ -226,22 +226,23 @@ VARIABLE REGISTER WEIGHTS
 Initial phi equivalence classes
 Complete equivalence classes
 INITIAL ASM
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
   jmp bend
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $400
     jmp breturn
-  //SEG5 main::@return
+  //SEG6 main::@return
   breturn:
-  //SEG6 [2] return  [ ]
+  //SEG7 [2] return  [ ]
     rts
 }
 
@@ -259,20 +260,21 @@ Removing instruction jmp bend
 Removing instruction jmp breturn
 Succesful ASM optimization Pass5NextJumpElimination
 ASSEMBLER
-//SEG0 @begin
+//SEG0 Global ZP labels
+//SEG1 @begin
 bbegin:
-//SEG1 [0] call main param-assignment [ ]
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
+//SEG3 @end
 bend:
-//SEG3 main
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $400
-  //SEG5 main::@return
+  //SEG6 main::@return
   breturn:
-  //SEG6 [2] return  [ ]
+  //SEG7 [2] return  [ ]
     rts
 }
 
@@ -281,17 +283,18 @@ Removing instruction bend:
 Removing instruction breturn:
 Succesful ASM optimization Pass5UnusedLabelElimination
 ASSEMBLER
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $400
-  //SEG5 main::@return
-  //SEG6 [2] return  [ ]
+  //SEG6 main::@return
+  //SEG7 [2] return  [ ]
     rts
 }
 
@@ -304,17 +307,18 @@ FINAL SYMBOL TABLE
 
 
 FINAL CODE
-//SEG0 @begin
-//SEG1 [0] call main param-assignment [ ]
+//SEG0 Global ZP labels
+//SEG1 @begin
+//SEG2 [0] call main param-assignment [ ]
   jsr main
-//SEG2 @end
-//SEG3 main
+//SEG3 @end
+//SEG4 main
 main: {
-  //SEG4 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
+  //SEG5 [1] *((word) 1024) ← (byte) 1 [ ] -- _star_cowo1=coby2 
     lda #$1
     sta $400
-  //SEG5 main::@return
-  //SEG6 [2] return  [ ]
+  //SEG6 main::@return
+  //SEG7 [2] return  [ ]
     rts
 }
 

src/main/java/dk/camelot64/kickc/test/ref/voronoi.asm

@@ -1,34 +1,35 @@
+  .label numpoints = 8
   jsr main
 main: {
     lda #$1
-    sta $2
+    sta render.y
     ldy #$5
     lda #$0
-    sta $8
+    sta numpoints
     lda #$5
     jsr addpoint
     lda #$2
-    sta $2
+    sta render.y
     ldy #$8
     lda #$f
     jsr addpoint
     lda #$3
-    sta $2
+    sta render.y
     ldy #$e
     lda #$6
     jsr addpoint
     lda #$4
-    sta $2
+    sta render.y
     ldy #$2
     lda #$22
     jsr addpoint
     lda #$5
-    sta $2
+    sta render.y
     ldy #$11
     lda #$15
     jsr addpoint
     lda #$7
-    sta $2
+    sta render.y
     ldy #$16
     lda #$1f
     jsr addpoint
@@ -102,138 +103,148 @@ animate: {
     rts
 }
 render: {
+    .label x = 5
+    .label colline = 3
+    .label y = 2
     lda #<$d800
-    sta $3
+    sta colline
     lda #>$d800
-    sta $3+$1
+    sta colline+$1
     lda #$0
-    sta $2
+    sta y
   b1:
     lda #$0
-    sta $5
+    sta x
   b2:
-    lda $5
-    sta $9
-    lda $2
-    sta $a
+    lda x
+    sta findcol.x
+    lda y
+    sta findcol.y
     jsr findcol
     tya
-    ldy $5
-    sta ($3),y
-    inc $5
-    lda $5
+    ldy x
+    sta (colline),y
+    inc x
+    lda x
     cmp #$28
     bne b2
-    lda $3
+    lda colline
     clc
     adc #$28
-    sta $3
+    sta colline
     bcc !+
-    inc $3+$1
+    inc colline+$1
   !:
-    inc $2
-    lda $2
+    inc y
+    lda y
     cmp #$19
     bne b1
     rts
 }
 findcol: {
+    .label x = 9
+    .label y = 10
+    .label diff = 7
+    .label yp = 11
+    .label mindiff = 6
     ldy #$0
     lda #$ff
-    sta $6
+    sta mindiff
     ldx #$0
   b1:
     lda $1000,x
-    sta $7
+    sta diff
     lda $1100,x
-    sta $b
-    lda $9
-    cmp $7
+    sta yp
+    lda x
+    cmp diff
     bne b2
-    lda $a
-    cmp $b
+    lda y
+    cmp yp
     bne b2
     ldy #$0
   breturn:
     rts
   b2:
-    lda $9
-    cmp $7
+    lda x
+    cmp diff
     bcs b4
-    lda $7
+    lda diff
     sec
-    sbc $9
-    sta $7
+    sbc x
+    sta diff
   b5:
-    lda $a
-    cmp $b
+    lda y
+    cmp yp
     bcs b6
-    lda $b
+    lda yp
     sec
-    sbc $a
+    sbc y
     clc
-    adc $7
+    adc diff
   b7:
-    cmp $6
+    cmp mindiff
     bcs b21
     ldy $1200,x
   b8:
     inx
-    cpx $8
+    cpx numpoints
     bcc b19
     jmp breturn
   b19:
-    sta $6
+    sta mindiff
     jmp b1
   b21:
-    lda $6
+    lda mindiff
     jmp b8
   b6:
-    lda $a
+    lda y
     sec
-    sbc $b
+    sbc yp
     clc
-    adc $7
+    adc diff
     jmp b7
   b4:
-    lda $9
+    lda x
     sec
-    sbc $7
-    sta $7
+    sbc diff
+    sta diff
     jmp b5
 }
 initscreen: {
+    .label colline = 3
     lda #<$400
-    sta $3
+    sta render.colline
     lda #>$400
-    sta $3+$1
+    sta render.colline+$1
   b1:
     ldy #$0
     lda #$e6
-    sta ($3),y
-    inc $3
+    sta (render.colline),y
+    inc render.colline
     bne !+
-    inc $3+$1
+    inc render.colline+$1
   !:
-    lda $3+$1
+    lda render.colline+$1
     cmp #>$7e8
     bcc b1
     bne !+
-    lda $3
+    lda render.colline
     cmp #<$7e8
     bcc b1
   !:
     rts
 }
 addpoint: {
-    ldx $8
+    .label y = 2
+    ldx numpoints
     sta $1000,x
     tya
-    ldy $8
+    ldy numpoints
     sta $1100,y
-    lda $2
-    ldx $8
+    lda render.y
+    ldx numpoints
     sta $1200,x
-    inc $8
+    inc numpoints
     rts
 }

src/main/java/dk/camelot64/kickc/test/ref/voronoi.sym

@@ -9,7 +9,7 @@
 (void()) addpoint((byte) addpoint::x , (byte) addpoint::y , (byte) addpoint::c)
 (label) addpoint::@return
 (byte) addpoint::c
-(byte) addpoint::c#6 zp byte:2 0.6666666666666666
+(byte) addpoint::c#6 zp ZP_BYTE:2 y 0.6666666666666666
 (byte) addpoint::x
 (byte) addpoint::x#6 reg byte a 2.0
 (byte) addpoint::y
@@ -64,11 +64,11 @@
 (label) findcol::@9
 (label) findcol::@return
 (byte) findcol::diff
-(byte) findcol::diff#0 zp byte:7 20002.0
-(byte) findcol::diff#1 zp byte:7 20002.0
+(byte) findcol::diff#0 zp ZP_BYTE:7 diff 20002.0
+(byte) findcol::diff#1 zp ZP_BYTE:7 diff 20002.0
 (byte) findcol::diff#2 reg byte a 20002.0
 (byte) findcol::diff#3 reg byte a 20002.0
-(byte) findcol::diff#4 zp byte:7 10001.0
+(byte) findcol::diff#4 zp ZP_BYTE:7 diff 10001.0
 (byte) findcol::diff#6 reg byte a 13334.666666666666
 (byte) findcol::i
 (byte) findcol::i#1 reg byte x 10001.0
@@ -78,26 +78,26 @@
 (byte) findcol::mincol#11 reg byte y 1176.5882352941176
 (byte) findcol::mincol#2 reg byte y 10001.0
 (byte) findcol::mindiff
-(byte) findcol::mindiff#10 zp byte:6 1875.1875
+(byte) findcol::mindiff#10 zp ZP_BYTE:6 mindiff 1875.1875
 (byte) findcol::mindiff#11 reg byte a 10001.0
-(byte~) findcol::mindiff#13 zp byte:6 20002.0
+(byte~) findcol::mindiff#13 zp ZP_BYTE:6 mindiff 20002.0
 (byte~) findcol::mindiff#14 reg byte a 20002.0
 (byte) findcol::return
 (byte) findcol::return#0 reg byte y 3667.333333333333
 (byte) findcol::x
-(byte) findcol::x#0 zp byte:9 1863.8636363636363
+(byte) findcol::x#0 zp ZP_BYTE:9 x 1863.8636363636363
 (byte) findcol::xp
-(byte) findcol::xp#0 zp byte:7 10001.0
+(byte) findcol::xp#0 zp ZP_BYTE:7 diff 10001.0
 (byte) findcol::y
-(byte) findcol::y#0 zp byte:10 1863.8636363636363
+(byte) findcol::y#0 zp ZP_BYTE:10 y 1863.8636363636363
 (byte) findcol::yp
-(byte) findcol::yp#0 zp byte:11 6250.625
+(byte) findcol::yp#0 zp ZP_BYTE:11 yp 6250.625
 (void()) initscreen()
 (label) initscreen::@1
 (label) initscreen::@return
 (byte*) initscreen::screen
-(byte*) initscreen::screen#1 zp ptr byte:3 16.5
-(byte*) initscreen::screen#2 zp ptr byte:3 16.5
+(byte*) initscreen::screen#1 zp ZP_PTR_BYTE:3 colline 16.5
+(byte*) initscreen::screen#2 zp ZP_PTR_BYTE:3 colline 16.5
 (void()) main()
 (label) main::@1
 (label) main::@10
@@ -110,8 +110,8 @@
 (label) main::@8
 (label) main::@return
 (byte) numpoints
-(byte) numpoints#1 zp byte:8 455.13636363636346
-(byte) numpoints#19 zp byte:8 4.5
+(byte) numpoints#1 zp ZP_BYTE:8 numpoints 455.13636363636346
+(byte) numpoints#19 zp ZP_BYTE:8 numpoints 4.5
 (void()) render()
 (label) render::@1
 (label) render::@2
@@ -121,25 +121,25 @@
 (byte) render::col
 (byte) render::col#0 reg byte a 2002.0
 (byte*) render::colline
-(byte*) render::colline#1 zp ptr byte:3 67.33333333333333
-(byte*) render::colline#2 zp ptr byte:3 36.45454545454545
+(byte*) render::colline#1 zp ZP_PTR_BYTE:3 colline 67.33333333333333
+(byte*) render::colline#2 zp ZP_PTR_BYTE:3 colline 36.45454545454545
 (byte) render::x
-(byte) render::x#1 zp byte:5 1501.5
-(byte) render::x#2 zp byte:5 133.46666666666667
+(byte) render::x#1 zp ZP_BYTE:5 x 1501.5
+(byte) render::x#2 zp ZP_BYTE:5 x 133.46666666666667
 (byte) render::y
-(byte) render::y#1 zp byte:2 151.5
-(byte) render::y#2 zp byte:2 35.38235294117647
+(byte) render::y#1 zp ZP_BYTE:2 y 151.5
+(byte) render::y#2 zp ZP_BYTE:2 y 35.38235294117647
 
-zp byte:2 [ render::y#2 render::y#1 addpoint::c#6 ]
-zp ptr byte:3 [ render::colline#2 render::colline#1 initscreen::screen#2 initscreen::screen#1 ]
-zp byte:5 [ render::x#2 render::x#1 ]
+zp ZP_BYTE:2 y [ render::y#2 render::y#1 addpoint::c#6 ]
+zp ZP_PTR_BYTE:3 colline [ render::colline#2 render::colline#1 initscreen::screen#2 initscreen::screen#1 ]
+zp ZP_BYTE:5 x [ render::x#2 render::x#1 ]
 reg byte x [ findcol::i#12 findcol::i#1 ]
-zp byte:6 [ findcol::mindiff#10 findcol::mindiff#13 ]
+zp ZP_BYTE:6 mindiff [ findcol::mindiff#10 findcol::mindiff#13 ]
 reg byte y [ findcol::return#0 findcol::mincol#11 findcol::mincol#2 findcol::mincol#1 ]
-zp byte:7 [ findcol::diff#4 findcol::diff#1 findcol::diff#0 findcol::xp#0 ]
+zp ZP_BYTE:7 diff [ findcol::diff#4 findcol::diff#1 findcol::diff#0 findcol::xp#0 ]
 reg byte a [ findcol::mindiff#11 findcol::diff#6 findcol::diff#3 findcol::diff#2 findcol::mindiff#14 ]
 reg byte a [ addpoint::x#6 ]
-zp byte:8 [ numpoints#19 numpoints#1 ]
+zp ZP_BYTE:8 numpoints [ numpoints#19 numpoints#1 ]
 reg byte y [ addpoint::y#6 ]
 reg byte a [ animate::$0 ]
 reg byte a [ animate::$1 ]
@@ -161,9 +161,9 @@ reg byte a [ animate::$26 ]
 reg byte a [ animate::$27 ]
 reg byte a [ animate::$30 ]
 reg byte a [ animate::$31 ]
-zp byte:9 [ findcol::x#0 ]
-zp byte:10 [ findcol::y#0 ]
+zp ZP_BYTE:9 x [ findcol::x#0 ]
+zp ZP_BYTE:10 y [ findcol::y#0 ]
 reg byte a [ render::col#0 ]
-zp byte:11 [ findcol::yp#0 ]
+zp ZP_BYTE:11 yp [ findcol::yp#0 ]
 reg byte a [ findcol::$12 ]
 reg byte a [ findcol::$14 ]

src/main/java/dk/camelot64/kickc/test/ref/zpparammin.asm

@@ -0,0 +1,47 @@
+  jsr main
+main: {
+    ldy #$0
+  b1:
+    tya
+    tax
+    inx
+    tya
+    clc
+    adc #$2
+    sta sum.c
+    jsr sum
+    sta $400,y
+    tya
+    tax
+    inx
+    tya
+    clc
+    adc #$2
+    sta sum.c
+    jsr sum2
+    sta $428,y
+    iny
+    cpy #$b
+    bne b1
+    rts
+}
+sum2: {
+    .label c = 2
+    sty $ff
+    txa
+    clc
+    adc $ff
+    clc
+    adc sum.c
+    rts
+}
+sum: {
+    .label c = 2
+    sty $ff
+    txa
+    clc
+    adc $ff
+    clc
+    adc c
+    rts
+}

src/main/java/dk/camelot64/kickc/test/ref/zpparammin.cfg

@@ -0,0 +1,48 @@
+@begin: scope:[]  from
+  [0] call main param-assignment [ ]
+  to:@end
+@end: scope:[]  from @begin
+main: scope:[main]  from @begin
+  to:main::@1
+main::@1: scope:[main]  from main main::@4
+  [1] (byte) main::i#2 ← phi( main/(byte) 0 main::@4/(byte) main::i#1 ) [ main::i#2 ]
+  [2] (byte~) main::$0 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$0 ]
+  [3] (byte~) main::$1 ← (byte) main::i#2 + (byte) 2 [ main::i#2 main::$0 main::$1 ]
+  [4] (byte) sum::a#0 ← (byte) main::i#2 [ main::i#2 main::$0 main::$1 sum::a#0 ]
+  [5] (byte) sum::b#0 ← (byte~) main::$0 [ main::i#2 main::$1 sum::a#0 sum::b#0 ]
+  [6] (byte) sum::c#0 ← (byte~) main::$1 [ main::i#2 sum::a#0 sum::b#0 ]
+  [7] call sum param-assignment [ main::i#2 sum::return#0 sum::a#0 sum::b#0 ]
+  to:main::@3
+main::@3: scope:[main]  from main::@1
+  [8] (byte~) main::$2 ← (byte) sum::return#0 [ main::i#2 main::$2 ]
+  [9] *((word) 1024 + (byte) main::i#2) ← (byte~) main::$2 [ main::i#2 ]
+  [10] (byte~) main::$3 ← (byte) main::i#2 + (byte) 1 [ main::i#2 main::$3 ]
+  [11] (byte~) main::$4 ← (byte) main::i#2 + (byte) 2 [ main::i#2 main::$3 main::$4 ]
+  [12] (byte) sum2::a#0 ← (byte) main::i#2 [ main::i#2 main::$3 main::$4 sum2::a#0 ]
+  [13] (byte) sum2::b#0 ← (byte~) main::$3 [ main::i#2 main::$4 sum2::a#0 sum2::b#0 ]
+  [14] (byte) sum2::c#0 ← (byte~) main::$4 [ main::i#2 sum2::a#0 sum2::b#0 ]
+  [15] call sum2 param-assignment [ main::i#2 sum2::return#0 sum2::a#0 sum2::b#0 ]
+  to:main::@4
+main::@4: scope:[main]  from main::@3
+  [16] (byte~) main::$5 ← (byte) sum2::return#0 [ main::i#2 main::$5 ]
+  [17] *((word) 1064 + (byte) main::i#2) ← (byte~) main::$5 [ main::i#2 ]
+  [18] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
+  [19] if((byte) main::i#1!=(byte) 11) goto main::@1 [ main::i#1 ]
+  to:main::@return
+main::@return: scope:[main]  from main::@4
+  [20] return  [ ]
+  to:@return
+sum2: scope:[sum2]  from main::@3
+  [21] (byte~) sum2::$0 ← (byte) sum2::a#0 + (byte) sum2::b#0 [ main::i#2 sum2::a#0 sum2::b#0 sum2::$0 sum2::c#0 ]
+  [22] (byte) sum2::return#0 ← (byte~) sum2::$0 + (byte) sum2::c#0 [ main::i#2 sum2::return#0 sum2::a#0 sum2::b#0 ]
+  to:sum2::@return
+sum2::@return: scope:[sum2]  from sum2
+  [23] return  [ main::i#2 sum2::return#0 sum2::a#0 sum2::b#0 ]
+  to:@return
+sum: scope:[sum]  from main::@1
+  [24] (byte~) sum::$0 ← (byte) sum::a#0 + (byte) sum::b#0 [ main::i#2 sum::a#0 sum::b#0 sum::$0 sum::c#0 ]
+  [25] (byte) sum::return#0 ← (byte~) sum::$0 + (byte) sum::c#0 [ main::i#2 sum::return#0 sum::a#0 sum::b#0 ]
+  to:sum::@return
+sum::@return: scope:[sum]  from sum
+  [26] return  [ main::i#2 sum::return#0 sum::a#0 sum::b#0 ]
+  to:@return

src/main/java/dk/camelot64/kickc/test/ref/zpparammin.sym

@@ -0,0 +1,57 @@
+(label) @begin
+(label) @end
+(byte*) SCREEN
+(byte*) SCREEN2
+(void()) main()
+(byte~) main::$0 reg byte x 7.333333333333333
+(byte~) main::$1 reg byte a 7.333333333333333
+(byte~) main::$2 reg byte a 22.0
+(byte~) main::$3 reg byte x 7.333333333333333
+(byte~) main::$4 reg byte a 7.333333333333333
+(byte~) main::$5 reg byte a 22.0
+(label) main::@1
+(label) main::@3
+(label) main::@4
+(label) main::@return
+(byte) main::i
+(byte) main::i#1 reg byte y 16.5
+(byte) main::i#2 reg byte y 4.782608695652174
+(byte()) sum((byte) sum::a , (byte) sum::b , (byte) sum::c)
+(byte~) sum::$0 reg byte a 4.0
+(label) sum::@return
+(byte) sum::a
+(byte) sum::a#0 reg byte y 1.8571428571428572
+(byte) sum::b
+(byte) sum::b#0 reg byte x 2.1666666666666665
+(byte) sum::c
+(byte) sum::c#0 zp ZP_BYTE:2 c 13.0
+(byte) sum::return
+(byte) sum::return#0 reg byte a 4.333333333333333
+(byte()) sum2((byte) sum2::a , (byte) sum2::b , (byte) sum2::c)
+(byte~) sum2::$0 reg byte a 4.0
+(label) sum2::@return
+(byte) sum2::a
+(byte) sum2::a#0 reg byte y 1.8571428571428572
+(byte) sum2::b
+(byte) sum2::b#0 reg byte x 2.1666666666666665
+(byte) sum2::c
+(byte) sum2::c#0 zp ZP_BYTE:2 c 13.0
+(byte) sum2::return
+(byte) sum2::return#0 reg byte a 4.333333333333333
+
+reg byte y [ main::i#2 main::i#1 ]
+reg byte x [ main::$0 ]
+reg byte a [ main::$1 ]
+reg byte y [ sum::a#0 ]
+reg byte x [ sum::b#0 ]
+zp ZP_BYTE:2 c [ sum::c#0 sum2::c#0 ]
+reg byte a [ main::$2 ]
+reg byte x [ main::$3 ]
+reg byte a [ main::$4 ]
+reg byte y [ sum2::a#0 ]
+reg byte x [ sum2::b#0 ]
+reg byte a [ main::$5 ]
+reg byte a [ sum2::$0 ]
+reg byte a [ sum2::return#0 ]
+reg byte a [ sum::$0 ]
+reg byte a [ sum::return#0 ]

src/main/java/dk/camelot64/kickc/test/zpparammin.kc

@@ -0,0 +1,19 @@
+byte* SCREEN = $0400;
+byte* SCREEN2 = $0400+40;
+main();
+
+void main() {
+    for(byte i : 0..10) {
+        SCREEN[i] = sum(i,i+1,i+2);
+        SCREEN2[i] = sum2(i,i+1,i+2);
+    }
+}
+
+byte sum(byte a, byte b, byte c) {
+  return a+b+c;
+}
+
+
+byte sum2(byte a, byte b, byte c) {
+  return a+b+c;
+}