6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-02-20 00:29:10 +00:00
Code Issues Projects Releases Wiki Activity

Now there is only one ZP memory register type.

Browse Source
This commit is contained in:
jespergravgaard 2019-10-07 07:47:44 +02:00
parent 873adf0b26
commit 6961f121e7
9 changed files with 38 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstance.java
View File

@ -79,7 +79,7 @@ public class AsmFragmentInstance {
if(boundValue instanceof Variable) {
Variable boundVar = (Variable) boundValue;
Registers.Register register = boundVar.getAllocation();
if(register != null && register instanceof Registers.RegisterZp) {
if(register != null && register instanceof Registers.RegisterZpMem) {
return new AsmParameter(AsmFormat.getAsmParamName(boundVar, codeScopeRef), true);
} else if(register!=null && register instanceof Registers.RegisterMainMem) {
return new AsmParameter(AsmFormat.getAsmParamName(boundVar, codeScopeRef), false);

4
src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstanceSpecFactory.java
View File

@ -451,14 +451,14 @@ public class AsmFragmentInstanceSpecFactory {
private String getRegisterName(Registers.Register register) {
if(Registers.RegisterType.ZP_MEM.equals(register.getType())) {
// Examine if the ZP register is already bound
Registers.RegisterZp registerZp = (Registers.RegisterZp) register;
Registers.RegisterZpMem registerZp = (Registers.RegisterZpMem) register;
String zpNameIdx = null;
for(String boundName : bindings.keySet()) {
Value boundValue = bindings.get(boundName);
if(boundValue instanceof Variable) {
Registers.Register boundRegister = ((Variable) boundValue).getAllocation();
if(boundRegister != null && boundRegister.isZp()) {
Registers.RegisterZp boundRegisterZp = (Registers.RegisterZp) boundRegister;
Registers.RegisterZpMem boundRegisterZp = (Registers.RegisterZpMem) boundRegister;
if(registerZp.getZp() == boundRegisterZp.getZp()) {
// Found other register with same ZP address!
zpNameIdx = boundName.substring(boundName.length() - 1);

107
src/main/java/dk/camelot64/kickc/model/Registers.java
View File

@ -46,7 +46,6 @@ public class Registers {
REG_Y,
REG_X,
REG_ALU,
ZP_VAR,
ZP_MEM,
MAIN_MEM,
CONSTANT,
@ -124,58 +123,12 @@ public class Registers {
}
}
public static abstract class RegisterZp implements Register {
/** Two zero page addresses used as a register for a single unsigned word variable. */
public static class RegisterZpMem implements Register {
/** The ZP address used for the byte. */
private int zp;
RegisterZp(int zp) {
this.zp = zp;
}
public int getZp() {
return zp;
}
public abstract int getBytes();
@Override
public boolean isZp() {
return true;
}
@Override
public String toString() {
return "zp " + getType().toString() + ":" + zp;
}
@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;
return zp == that.zp;
}
@Override
public int hashCode() {
return zp+31*getClass().hashCode();
}
}
/** Two zero page addresses used as a register for a single unsigned word variable. */
public static class RegisterZpMem extends RegisterZp {
/** The number of bytes that the register takes up*/
private int bytes;
@ -185,7 +138,7 @@ public class Registers {
public RegisterZpMem(int zp, int bytes, boolean isNonRelocatable) {
super(zp);
this.zp = zp;
this.bytes = bytes;
this.isNonRelocatable = isNonRelocatable;
}
@ -194,6 +147,14 @@ public class Registers {
this(zp, bytes, false);
}
public int getZp() {
return zp;
}
@Override
public boolean isZp() {
return true;
}
@Override
public RegisterType getType() {
@ -224,52 +185,24 @@ public class Registers {
}
@Override
public boolean equals(Object o) {
return super.equals(o);
}
@Override
public int hashCode() {
return super.hashCode();
}
}
/** A zero page address used as a register for a declared register allocation. Size is initially unknown and will be resolved when performing allocation by setting the type. */
public static class RegisterZpDeclared extends RegisterZp {
public RegisterZpDeclared(int zp) {
super(zp);
}
@Override
public RegisterType getType() {
return RegisterType.ZP_MEM;
}
@Override
public boolean isNonRelocatable() {
return true;
}
@Override
public int getBytes() {
return -1;
}
public RegisterZpMem getZpRegister(int bytes) {
return new RegisterZpMem(getZp(), bytes, true);
public String toString(Program program) {
return toString();
}
@Override
public boolean equals(Object o) {
return super.equals(o);
if(this == o) return true;
if(o == null || getClass() != o.getClass()) return false;
RegisterZpMem that = (RegisterZpMem) o;
return zp == that.zp &&
bytes == that.bytes &&
isNonRelocatable == that.isNonRelocatable;
}
@Override
public int hashCode() {
return super.hashCode();
return Objects.hash(zp, bytes, isNonRelocatable);
}
}
/** A CPU byte register. */

2
src/main/java/dk/camelot64/kickc/model/values/ConstantSymbolPointer.java
View File

@ -40,7 +40,7 @@ public class ConstantSymbolPointer implements ConstantValue {
if(symbol instanceof Variable) {
Registers.Register allocation = ((Variable) symbol).getAllocation();
if(allocation!=null && allocation.isZp()) {
int zp = ((Registers.RegisterZp) allocation).getZp();
int zp = ((Registers.RegisterZpMem) allocation).getZp();
return new ConstantInteger((long)zp, SymbolType.BYTE);
}
}

2
src/main/java/dk/camelot64/kickc/passes/Pass0GenerateStatementSequence.java
View File

@ -715,7 +715,7 @@ public class Pass0GenerateStatementSequence extends KickCParserBaseVisitor<Objec
if(address>255) {
throw new CompileError("Error! Register not on zeropage " + directiveRegister.address, source);
}
Registers.Register register = new Registers.RegisterZpDeclared(address.intValue());
Registers.Register register = new Registers.RegisterZpMem(address.intValue(), -1, true);
lValue.setDeclaredRegister(register);
}
} else {

2
src/main/java/dk/camelot64/kickc/passes/Pass4AssertZeropageAllocation.java
View File

@ -22,7 +22,7 @@ public class Pass4AssertZeropageAllocation extends Pass2Base {
for(Variable variable : allVariables) {
Registers.Register allocation = variable.getAllocation();
if(allocation!=null && allocation.isZp()) {
int zp = ((Registers.RegisterZp) allocation).getZp();
int zp = ((Registers.RegisterZpMem) allocation).getZp();
int sizeBytes = variable.getType().getSizeBytes();
if(zp+sizeBytes>0x100) {
// Allocation is outside ZP!

6
src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java
View File

@ -269,8 +269,8 @@ public class Pass4CodeGeneration {
Registers.Register allocation = param.getAllocation();
if(i++ > 0) signature.append(", ");
signature.append(param.getType().getTypeName()).append(" ");
if(allocation instanceof Registers.RegisterZp) {
Registers.RegisterZp registerZp = (Registers.RegisterZp) allocation;
if(allocation instanceof Registers.RegisterZpMem) {
Registers.RegisterZpMem registerZp = (Registers.RegisterZpMem) allocation;
signature.append("zeropage(").append(AsmFormat.getAsmNumber(registerZp.getZp())).append(")");
} else if(allocation instanceof Registers.RegisterAByte) {
signature.append("register(A)");
@ -666,7 +666,7 @@ public class Pass4CodeGeneration {
for(Variable scopeVar : scopeVars) {
Registers.Register register = scopeVar.getAllocation();
if(register != null && register.isZp()) {
Registers.RegisterZp registerZp = (Registers.RegisterZp) register;
Registers.RegisterZpMem registerZp = (Registers.RegisterZpMem) register;
String asmName = scopeVar.getAsmName();
if(asmName != null && !added.contains(asmName)) {
// Add any comments

6
src/main/java/dk/camelot64/kickc/passes/Pass4RegisterUpliftPotentialInitialize.java
View File

@ -41,15 +41,15 @@ public class Pass4RegisterUpliftPotentialInitialize extends Pass2Base {
}
}
if(declaredRegister != null) {
if(declaredRegister instanceof Registers.RegisterZpDeclared) {
Registers.RegisterZpMem zpRegister = ((Registers.RegisterZpDeclared) declaredRegister).getZpRegister(bytes);
if(declaredRegister instanceof Registers.RegisterZpMem) {
int zp = ((Registers.RegisterZpMem) declaredRegister).getZp();
Registers.RegisterZpMem zpRegister = new Registers.RegisterZpMem(zp, bytes, true);
registerPotentials.setPotentialRegisters(equivalenceClass, Arrays.asList(zpRegister));
} else {
registerPotentials.setPotentialRegisters(equivalenceClass, Arrays.asList(declaredRegister));
}
} else {
Registers.Register defaultRegister = equivalenceClass.getRegister();
Registers.RegisterType registerType = defaultRegister.getType();
List<Registers.Register> potentials = new ArrayList<>();
potentials.add(defaultRegister);
boolean isByte2 = defaultRegister.isZp() && defaultRegister.getBytes() == 1;

10
src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java
View File

@ -40,8 +40,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.RegisterZpDeclared) { //TODO: Handle register/memory/storage strategy differently!
int zp = ((Registers.RegisterZpDeclared) variable.getDeclaredRegister()).getZp();
if(variable.getDeclaredRegister() instanceof Registers.RegisterZpMem) {
int zp = ((Registers.RegisterZpMem) variable.getDeclaredRegister()).getZp();
int sizeBytes = variable.getType().getSizeBytes();
for(int i=0;i<sizeBytes; i++) {
if(!reservedZp.contains(zp+i))
@ -59,8 +59,10 @@ public class Pass4RegistersFinalize extends Pass2Base {
Registers.Register declaredRegister = variable.getDeclaredRegister(); //TODO: Handle register/memory/storage strategy differently!
Registers.Register register = declaredRegister;
if(declaredRegister !=null) {
if(declaredRegister instanceof Registers.RegisterZpDeclared) {
register = ((Registers.RegisterZpDeclared) declaredRegister).getZpRegister(variable.getType().getSizeBytes());
if(declaredRegister instanceof Registers.RegisterZpMem) {
int zp = ((Registers.RegisterZpMem) declaredRegister).getZp();
int bytes = variable.getType().getSizeBytes();
register = new Registers.RegisterZpMem(zp, bytes, true);
} else if(equivalenceClass.getRegister()!=null && !declaredRegister.equals(equivalenceClass.getRegister())) {
throw new CompileError("Equivalence class has variables with different declared registers \n" +
" - equivalence class: " + equivalenceClass.toString(true) + "\n" +