From 2fddd14a0aa4510ec3504422616ceeb1b170ba82 Mon Sep 17 00:00:00 2001 From: jespergravgaard Date: Sun, 22 Dec 2019 22:31:20 +0100 Subject: [PATCH] Moving Variable properties towards semantic names (nomodify, volatile, optimize, ...). --- .../model/LiveRangeEquivalenceClass.java | 2 +- .../kickc/model/VariableBuilder.java | 16 +-- .../camelot64/kickc/model/symbols/Scope.java | 2 +- .../kickc/model/symbols/Variable.java | 122 +++++++++--------- .../passes/Pass1AssertNoConstParams.java | 2 +- .../Pass1EarlyConstantIdentification.java | 2 +- ...ss1GenerateSingleStaticAssignmentForm.java | 4 +- .../kickc/passes/Pass2AliasElimination.java | 4 +- .../passes/Pass2ConstantIdentification.java | 6 +- .../Pass2DuplicateRValueIdentification.java | 2 +- .../passes/Pass2IdenticalPhiElimination.java | 2 +- .../Pass2LoopHeadConstantIdentification.java | 2 +- .../kickc/passes/Pass4CodeGeneration.java | 4 +- ...s4LiveRangeEquivalenceClassesFinalize.java | 2 +- ...ass4RegisterUpliftPotentialInitialize.java | 10 +- .../kickc/passes/Pass4RegistersFinalize.java | 6 +- .../passes/PassNEliminateUnusedVars.java | 14 +- 17 files changed, 101 insertions(+), 101 deletions(-) diff --git a/src/main/java/dk/camelot64/kickc/model/LiveRangeEquivalenceClass.java b/src/main/java/dk/camelot64/kickc/model/LiveRangeEquivalenceClass.java index 9c8f94fb0..a7a32ef24 100644 --- a/src/main/java/dk/camelot64/kickc/model/LiveRangeEquivalenceClass.java +++ b/src/main/java/dk/camelot64/kickc/model/LiveRangeEquivalenceClass.java @@ -143,7 +143,7 @@ public class LiveRangeEquivalenceClass { public boolean hasVolatile(Program program) { for(VariableRef varRef : variables) { Variable variable = program.getScope().getVariable(varRef); - if(variable.isVolatile()) { + if(variable.isAnyVolatile()) { return true; } } diff --git a/src/main/java/dk/camelot64/kickc/model/VariableBuilder.java b/src/main/java/dk/camelot64/kickc/model/VariableBuilder.java index a279f12c5..e324a6314 100644 --- a/src/main/java/dk/camelot64/kickc/model/VariableBuilder.java +++ b/src/main/java/dk/camelot64/kickc/model/VariableBuilder.java @@ -52,16 +52,16 @@ public class VariableBuilder { */ public Variable build() { Variable variable = new Variable(varName, getKind(), type, scope, getMemoryArea(), dataSegment, arraySpec, null); - variable.setDeclaredConst(this.isConstant()); - variable.setDeclaredVolatile(this.isVolatile()); - variable.setDeclaredExport(this.isExport()); - variable.setDeclaredAsRegister(this.isOptimize()); - variable.setDeclaredRegister(this.getRegister()); - if(variable.getDeclaredRegister() instanceof Registers.RegisterMainMem) { - ((Registers.RegisterMainMem) variable.getDeclaredRegister()).setVariableRef(variable.getVariableRef()); + variable.setNoModify(this.isConstant()); + variable.setVolatile(this.isVolatile()); + variable.setExport(this.isExport()); + variable.setOptimize(this.isOptimize()); + variable.setRegister(this.getRegister()); + if(variable.getRegister() instanceof Registers.RegisterMainMem) { + ((Registers.RegisterMainMem) variable.getRegister()).setVariableRef(variable.getVariableRef()); } variable.setMemoryArea(this.getMemoryArea()); - variable.setDeclaredAlignment(this.getAlignment()); + variable.setMemoryAlignment(this.getAlignment()); scope.add(variable); return variable; } diff --git a/src/main/java/dk/camelot64/kickc/model/symbols/Scope.java b/src/main/java/dk/camelot64/kickc/model/symbols/Scope.java index d2f1a056c..3b7533f17 100644 --- a/src/main/java/dk/camelot64/kickc/model/symbols/Scope.java +++ b/src/main/java/dk/camelot64/kickc/model/symbols/Scope.java @@ -378,7 +378,7 @@ public abstract class Scope implements Symbol, Serializable { if(symVar.isKindLoadStore()) { res.append(" loadstore"); } - Registers.Register declRegister = symVar.getDeclaredRegister(); + Registers.Register declRegister = symVar.getRegister(); if(declRegister != null) { res.append(" !" + declRegister); } diff --git a/src/main/java/dk/camelot64/kickc/model/symbols/Variable.java b/src/main/java/dk/camelot64/kickc/model/symbols/Variable.java index c4cd0d07a..93d9cc797 100644 --- a/src/main/java/dk/camelot64/kickc/model/symbols/Variable.java +++ b/src/main/java/dk/camelot64/kickc/model/symbols/Variable.java @@ -58,26 +58,20 @@ public class Variable implements Symbol { /** The type of the variable. VAR means the type is unknown, and has not been inferred yet. [ALL] */ private SymbolType type; - /** Specifies that the variable must be aligned in memory. Only allowed for arrays & strings. [Only Variables in memory and arrays] */ - private Integer declaredAlignment; - - /** Specifies the register the variable must be put into during execution. [Only variables] */ - private Registers.Register declaredRegister; - - /** Specifies that the variable is declared as const */ - private boolean declaredConst; + /** Specifies that the variable is not allowed to be modified (const keyword) */ + private boolean noModify; /** Specifies that the variable must always live in memory to be available for any multi-threaded accees (eg. in interrupts). [Only Variables] */ - private boolean declaredVolatile; + private boolean isVolatile; /** Specifies that the variable must always live in memory to be available for any multi-threaded accees (eg. in interrupts). [Only variables] TODO: Remove this */ private boolean inferredVolatile; /** Specifies that the variable must always be added to the output ASM even if it is never used anywhere. */ - private boolean declaredExport; + private boolean export; - /** Specifies that the variable must live in a register if possible (CPU register or ZP-address). */ - private boolean declaredAsRegister; + /** Specifies that the shoulw be optimized (register keyword). */ + private boolean optimize; /** Memory area used for storing the variable (if is is stored in memory). */ public enum MemoryArea { @@ -87,12 +81,18 @@ public class Variable implements Symbol { /** The memory area where the variable lives (if stored in memory). [Only variables and arrays] */ private MemoryArea memoryArea; - /** Comments preceding the procedure in the source code. [ALL] */ - private List comments; + /** Specifies that the variable must be aligned in memory. Only allowed for arrays & strings. [Only Variables in memory and arrays] */ + private Integer memoryAlignment; /** The data segment to put the variable into (if it is allocated in memory). [Only variables stored in memory and arrays] */ private String dataSegment; + /** Specifies the hard-coded register the variable must be put into during execution. [Only variables] */ + private Registers.Register register; + + /** Comments preceding the procedure in the source code. [ALL] */ + private List comments; + /** The initial compiletime-value of the variable. Null if no initial value present. [Constants, Arrays, global/local-static loadstore-variables ] */ private ConstantValue initValue; @@ -182,12 +182,12 @@ public class Variable implements Symbol { if(!phiMaster.isKindPhiMaster()) throw new InternalError("Cannot version non-PHI variable " + phiMaster.toString()); Variable version = new Variable(phiMaster.getName() + "#" + versionNum, Kind.PHI_VERSION, phiMaster.getType(), phiMaster.getScope(), phiMaster.getMemoryArea(), phiMaster.getDataSegment(), phiMaster.getArraySpec(), null); - version.setDeclaredAlignment(phiMaster.getDeclaredAlignment()); - version.setDeclaredAsRegister(phiMaster.isDeclaredAsRegister()); - version.setDeclaredConst(phiMaster.isDeclaredConst()); - version.setDeclaredRegister(phiMaster.getDeclaredRegister()); - version.setDeclaredVolatile(phiMaster.isDeclaredVolatile()); - version.setDeclaredExport(phiMaster.isDeclaredExport()); + version.setMemoryAlignment(phiMaster.getMemoryAlignment()); + version.setOptimize(phiMaster.isOptimize()); + version.setNoModify(phiMaster.isNoModify()); + version.setRegister(phiMaster.getRegister()); + version.setVolatile(phiMaster.isVolatile()); + version.setExport(phiMaster.isExport()); version.setInferredVolatile(phiMaster.isInferredVolatile()); version.setComments(phiMaster.getComments()); return version; @@ -226,12 +226,12 @@ public class Variable implements Symbol { */ public static Variable createConstant(Variable variable, ConstantValue constantValue) { Variable constVar = new Variable(variable.getName(), Kind.CONSTANT, variable.getType(), variable.getScope(), MemoryArea.MAIN_MEMORY, variable.getDataSegment(), variable.getArraySpec(), constantValue); - constVar.setDeclaredAlignment(variable.getDeclaredAlignment()); - constVar.setDeclaredAsRegister(variable.isDeclaredAsRegister()); - constVar.setDeclaredConst(variable.isDeclaredConst()); - constVar.setDeclaredRegister(variable.getDeclaredRegister()); - constVar.setDeclaredVolatile(variable.isDeclaredVolatile()); - constVar.setDeclaredExport(variable.isDeclaredExport()); + constVar.setMemoryAlignment(variable.getMemoryAlignment()); + constVar.setOptimize(variable.isOptimize()); + constVar.setNoModify(variable.isNoModify()); + constVar.setRegister(variable.getRegister()); + constVar.setVolatile(variable.isVolatile()); + constVar.setExport(variable.isExport()); constVar.setInferredVolatile(variable.isInferredVolatile()); constVar.setComments(variable.getComments()); return constVar; @@ -246,12 +246,12 @@ public class Variable implements Symbol { */ public static Variable createCopy(String name, Scope scope, Variable original) { Variable copy = new Variable(name, original.getKind(), original.getType(), scope, original.getMemoryArea(), original.getDataSegment(), original.getArraySpec(), original.getInitValue()); - copy.setDeclaredAlignment(original.getDeclaredAlignment()); - copy.setDeclaredAsRegister(original.isDeclaredAsRegister()); - copy.setDeclaredConst(original.isDeclaredConst()); - copy.setDeclaredVolatile(original.isDeclaredVolatile()); - copy.setDeclaredExport(original.isDeclaredExport()); - copy.setDeclaredRegister(original.getDeclaredRegister()); + copy.setMemoryAlignment(original.getMemoryAlignment()); + copy.setOptimize(original.isOptimize()); + copy.setNoModify(original.isNoModify()); + copy.setVolatile(original.isVolatile()); + copy.setExport(original.isExport()); + copy.setRegister(original.getRegister()); copy.setInferredVolatile(original.isInferredVolatile()); copy.setComments(original.getComments()); return copy; @@ -279,10 +279,10 @@ public class Variable implements Symbol { // For others the kind is preserved from the member definition memberVariable = new Variable(name, structVar.getKind(), memberDefinition.getType(), structVar.getScope(), memoryArea, structVar.getDataSegment(), memberDefinition.getArraySpec(), memberDefinition.getInitValue()); } - memberVariable.setDeclaredVolatile(structVar.isDeclaredVolatile()); + memberVariable.setVolatile(structVar.isVolatile()); memberVariable.setInferredVolatile(structVar.isInferredVolatile()); - memberVariable.setDeclaredConst(structVar.isDeclaredConst()); - memberVariable.setDeclaredExport(structVar.isDeclaredExport()); + memberVariable.setNoModify(structVar.isNoModify()); + memberVariable.setExport(structVar.isExport()); return memberVariable; } @@ -460,36 +460,36 @@ public class Variable implements Symbol { } } - public boolean isDeclaredConst() { - return declaredConst; + public boolean isNoModify() { + return noModify; } - public void setDeclaredConst(boolean declaredConst) { - this.declaredConst = declaredConst; + public void setNoModify(boolean noModify) { + this.noModify = noModify; } - public Integer getDeclaredAlignment() { - return declaredAlignment; + public Integer getMemoryAlignment() { + return memoryAlignment; } - public void setDeclaredAlignment(Integer declaredAlignment) { - this.declaredAlignment = declaredAlignment; + public void setMemoryAlignment(Integer memoryAlignment) { + this.memoryAlignment = memoryAlignment; } - public Registers.Register getDeclaredRegister() { - return declaredRegister; + public Registers.Register getRegister() { + return register; } - public void setDeclaredRegister(Registers.Register declaredRegister) { - this.declaredRegister = declaredRegister; + public void setRegister(Registers.Register register) { + this.register = register; } - public boolean isDeclaredVolatile() { - return declaredVolatile; + public boolean isVolatile() { + return isVolatile; } - public void setDeclaredVolatile(boolean declaredVolatile) { - this.declaredVolatile = declaredVolatile; + public void setVolatile(boolean aVolatile) { + this.isVolatile = aVolatile; } public void setInferredVolatile(boolean inferredVolatile) { @@ -500,24 +500,24 @@ public class Variable implements Symbol { return inferredVolatile; } - public boolean isVolatile() { - return declaredVolatile || inferredVolatile; + public boolean isAnyVolatile() { + return isVolatile || inferredVolatile; } - public boolean isDeclaredExport() { - return declaredExport; + public boolean isExport() { + return export; } - public void setDeclaredExport(boolean declaredExport) { - this.declaredExport = declaredExport; + public void setExport(boolean export) { + this.export = export; } - public boolean isDeclaredAsRegister() { - return declaredAsRegister; + public boolean isOptimize() { + return optimize; } - public void setDeclaredAsRegister(boolean declaredAsRegister) { - this.declaredAsRegister = declaredAsRegister; + public void setOptimize(boolean optimize) { + this.optimize = optimize; } public MemoryArea getMemoryArea() { diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass1AssertNoConstParams.java b/src/main/java/dk/camelot64/kickc/passes/Pass1AssertNoConstParams.java index defcf5506..5c09c162a 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass1AssertNoConstParams.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass1AssertNoConstParams.java @@ -18,7 +18,7 @@ public class Pass1AssertNoConstParams extends Pass1Base { public boolean step() { for(Procedure procedure : getScope().getAllProcedures(true)) { for(Variable parameter : procedure.getParameters()) { - if(parameter.isDeclaredConst()) { + if(parameter.isNoModify()) { throw new CompileError("Error! Const parameters not supported "+parameter.getName()+" in "+ procedure.getFullName()+"()"); } } diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass1EarlyConstantIdentification.java b/src/main/java/dk/camelot64/kickc/passes/Pass1EarlyConstantIdentification.java index bdeb00995..5b296a1d8 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass1EarlyConstantIdentification.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass1EarlyConstantIdentification.java @@ -37,7 +37,7 @@ public class Pass1EarlyConstantIdentification extends Pass1Base { List removeStmt = new ArrayList<>(); for(Variable variable : getProgram().getScope().getAllVariables(true)) { SymbolVariableRef variableRef = variable.getRef(); - if(!variable.isDeclaredConst() && !variable.isVolatile() && !variableRef.isIntermediate()) { + if(!variable.isNoModify() && !variable.isAnyVolatile() && !variableRef.isIntermediate()) { if(variable.getScope() instanceof StructDefinition) // Skip structs continue; diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java b/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java index f25c430bf..bfa82a6f9 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java @@ -82,7 +82,7 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base { private void versionAssignment(VariableRef lValueRef, ProgramValue programLValue, StatementSource source) { Variable assignedVar = getScope().getVariable(lValueRef); if(assignedVar.isKindPhiMaster()) { - if(assignedVar.isDeclaredConst()) + if(assignedVar.isNoModify()) throw new InternalError("Error! Constants can not be versioned ", source); Variable version = assignedVar.createVersion(); programLValue.set(version.getRef()); @@ -157,7 +157,7 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base { if(rValueVar.isKindPhiMaster()) { // rValue needs versioning - look for version in statements Variable rSymbol = rValueVar; - if(rSymbol.isDeclaredConst()) { + if(rSymbol.isNoModify()) { // A constant - find the single created version Scope scope = rSymbol.getScope(); Collection versions = scope.getVersions(rSymbol); diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2AliasElimination.java b/src/main/java/dk/camelot64/kickc/passes/Pass2AliasElimination.java index b1268a30b..3e9e01c96 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2AliasElimination.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2AliasElimination.java @@ -93,7 +93,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization { String unversionedFullName = null; for(VariableRef variableRef : aliasSet.getVars()) { Variable variable = programScope.getVariable(variableRef); - if(variable.isVolatile() || variable.isKindLoadStore()) { + if(variable.isAnyVolatile() || variable.isKindLoadStore()) { anyVolatile = true; } if(unversionedFullName == null) { @@ -420,7 +420,7 @@ public class Pass2AliasElimination extends Pass2SsaOptimization { String name; int score; Variable variable = scope.getVariable(var); - if(variable.isDeclaredConst() || variable.isKindConstant()) { + if(variable.isNoModify() || variable.isKindConstant()) { name = var.getFullNameUnversioned(); score = 100; } else if(var.isVersion()) { diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2ConstantIdentification.java b/src/main/java/dk/camelot64/kickc/passes/Pass2ConstantIdentification.java index 332468b19..f27e2eb4f 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2ConstantIdentification.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2ConstantIdentification.java @@ -137,7 +137,7 @@ public class Pass2ConstantIdentification extends Pass2SsaOptimization { if(lValue instanceof VariableRef) { VariableRef varRef = (VariableRef) lValue; Variable var = getScope().getVariable(varRef); - if(var.isVolatile() || var.isKindLoadStore()) + if(var.isAnyVolatile() || var.isKindLoadStore()) // Do not examine volatiles and non-versioned variables continue; ConstantValue constant = getConstant(assignment.getrValue2()); @@ -153,7 +153,7 @@ public class Pass2ConstantIdentification extends Pass2SsaOptimization { if(getConstant(phiRValue.getrValue()) != null) { VariableRef varRef = phiVariable.getVariable(); Variable var = getScope().getVariable(varRef); - if(var.isVolatile() || var.isKindLoadStore()) + if(var.isAnyVolatile() || var.isKindLoadStore()) // Do not examine volatiles and non-versioned variables continue; ConstantValue constant = getConstant(phiRValue.getrValue()); @@ -167,7 +167,7 @@ public class Pass2ConstantIdentification extends Pass2SsaOptimization { // Look for constants among non-versioned variables for(Variable variable : getScope().getAllVariables(true)) { - if(variable.isVolatile() || !variable.isKindLoadStore()) + if(variable.isAnyVolatile() || !variable.isKindLoadStore()) // Do not examine volatiles, non-constants or versioned variables continue; List assignments = getGraph().getAssignments(variable.getRef()); diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2DuplicateRValueIdentification.java b/src/main/java/dk/camelot64/kickc/passes/Pass2DuplicateRValueIdentification.java index 8e65773e2..57f9d7c8c 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2DuplicateRValueIdentification.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2DuplicateRValueIdentification.java @@ -97,7 +97,7 @@ public class Pass2DuplicateRValueIdentification extends Pass2SsaOptimization { isVol.set(true); if(programValue.get() instanceof VariableRef) { Variable variable = getScope().getVariable((VariableRef) programValue.get()); - if(variable.isVolatile()) + if(variable.isAnyVolatile() ) isVol.set(true); } }; diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2IdenticalPhiElimination.java b/src/main/java/dk/camelot64/kickc/passes/Pass2IdenticalPhiElimination.java index 507ea92b8..a1560b203 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2IdenticalPhiElimination.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2IdenticalPhiElimination.java @@ -38,7 +38,7 @@ public class Pass2IdenticalPhiElimination extends Pass2SsaOptimization { for(StatementPhiBlock.PhiRValue phiRValue : phiVariable.getValues()) { if(phiRValue.getrValue() instanceof SymbolVariableRef) { Variable symbolVar = (Variable) getScope().getSymbol((SymbolVariableRef) phiRValue.getrValue()); - if(symbolVar.getDeclaredRegister() != null) { //TODO: Handle register/memory/storage strategy differently! + if(symbolVar.getRegister() != null) { //TODO: Handle register/memory/storage strategy differently! // Do not collapse PHI's for variables with declared registers (this prevents procedure parameters from being turned into constants) identical = false; break; diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass2LoopHeadConstantIdentification.java b/src/main/java/dk/camelot64/kickc/passes/Pass2LoopHeadConstantIdentification.java index 3840fb9df..6225c36a1 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass2LoopHeadConstantIdentification.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass2LoopHeadConstantIdentification.java @@ -142,7 +142,7 @@ public class Pass2LoopHeadConstantIdentification extends Pass2SsaOptimization { } if(programValue.get() instanceof VariableRef) { Variable variable = getScope().getVariable((VariableRef) programValue.get()); - if(variable.isVolatile()) + if(variable.isAnyVolatile()) isVol.set(true); } }, null, null); diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java b/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java index fed51da0e..0118331bc 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java @@ -477,7 +477,7 @@ public class Pass4CodeGeneration { // Add any comments generateComments(asm, constantVar.getComments()); // Add any alignment - Integer declaredAlignment = constantVar.getDeclaredAlignment(); + Integer declaredAlignment = constantVar.getMemoryAlignment(); if(declaredAlignment != null) { String alignment = AsmFormat.getAsmNumber(declaredAlignment); asm.addDataAlignment(alignment); @@ -522,7 +522,7 @@ public class Pass4CodeGeneration { // Add any comments generateComments(asm, variable.getComments()); // Add any alignment - Integer declaredAlignment = variable.getDeclaredAlignment(); + Integer declaredAlignment = variable.getMemoryAlignment(); if(declaredAlignment != null) { String alignment = AsmFormat.getAsmNumber(declaredAlignment); asm.addDataAlignment(alignment); diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass4LiveRangeEquivalenceClassesFinalize.java b/src/main/java/dk/camelot64/kickc/passes/Pass4LiveRangeEquivalenceClassesFinalize.java index a9f960479..a4a6f8ead 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass4LiveRangeEquivalenceClassesFinalize.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass4LiveRangeEquivalenceClassesFinalize.java @@ -33,7 +33,7 @@ public class Pass4LiveRangeEquivalenceClassesFinalize extends Pass2Base { // Add all versions of volatile variables to the same equivalence class for(Variable variable : getSymbols().getAllVariables(true)) { - if(variable.isKindPhiVersion() && variable.isVolatile()) { + if(variable.isKindPhiVersion() && variable.isAnyVolatile()) { // Found a volatile non-versioned variable for(Variable otherVariable : variable.getScope().getAllVariables(false)) { if(otherVariable.isKindPhiVersion()) { diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass4RegisterUpliftPotentialInitialize.java b/src/main/java/dk/camelot64/kickc/passes/Pass4RegisterUpliftPotentialInitialize.java index 63004193a..982cf052e 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass4RegisterUpliftPotentialInitialize.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass4RegisterUpliftPotentialInitialize.java @@ -28,15 +28,15 @@ public class Pass4RegisterUpliftPotentialInitialize extends Pass2Base { int bytes = -1; for(VariableRef varRef : equivalenceClass.getVariables()) { Variable variable = getProgram().getScope().getVariable(varRef); - if(variable.getDeclaredRegister() != null) { - if(declaredRegister != null && !declaredRegister.equals(variable.getDeclaredRegister())) { + if(variable.getRegister() != null) { + if(declaredRegister != null && !declaredRegister.equals(variable.getRegister())) { throw new CompileError("Equivalence class has variables with different declared registers \n" + " - equivalence class: " + equivalenceClass.toString(true) + "\n" + " - one register: " + declaredRegister.toString() + "\n" + - " - other register: " + variable.getDeclaredRegister().toString() + " - other register: " + variable.getRegister().toString() ); } - declaredRegister = variable.getDeclaredRegister(); + declaredRegister = variable.getRegister(); bytes = variable.getType().getSizeBytes(); } } @@ -78,7 +78,7 @@ public class Pass4RegisterUpliftPotentialInitialize extends Pass2Base { private boolean varVolatile(LiveRangeEquivalenceClass equivalenceClass) { for(VariableRef variableRef : equivalenceClass.getVariables()) { Variable variable = getSymbols().getVariable(variableRef); - if(variable.isVolatile() || variable.isKindLoadStore()) { + if(variable.isAnyVolatile() || variable.isKindLoadStore()) { return true; } } diff --git a/src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java b/src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java index 743cdd3fd..72f2a6925 100644 --- a/src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java +++ b/src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java @@ -37,8 +37,8 @@ public class Pass4RegistersFinalize extends Pass2Base { } // Add all ZP's declared hardcoded register for a live variable for(Variable variable : getSymbols().getAllVariables(true)) { - if(variable.getDeclaredRegister() instanceof Registers.RegisterZpMem) { - int zp = ((Registers.RegisterZpMem) variable.getDeclaredRegister()).getZp(); + if(variable.getRegister() instanceof Registers.RegisterZpMem) { + int zp = ((Registers.RegisterZpMem) variable.getRegister()).getZp(); int sizeBytes = variable.getType().getSizeBytes(); for(int i=0;i