6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2024-08-02 09:29:35 +00:00
Code Issues Projects Releases Wiki Activity

StructMemberReferences rewrite now using ValueSources.

Browse Source
This commit is contained in:
jespergravgaard 2020-02-06 01:08:55 +01:00
parent 511020649a
commit 0057e16517
56 changed files with 1056 additions and 1531 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/main/java/dk/camelot64/kickc/passes/Pass1UnwindStructValues.java
View File

@ -70,6 +70,7 @@ public class Pass1UnwindStructValues extends Pass1Base {
ProgramValueIterator.execute(
getProgram(), (programValue, currentStmt, stmtIt, currentBlock) -> {
if(programValue.get() instanceof StructMemberRef) {
/*
StructMemberRef structMemberRef = (StructMemberRef) programValue.get();
if(structMemberRef.getStruct() instanceof VariableRef) {
StructUnwinding memberVariables = getStructMemberUnwinding(structMemberRef.getStruct(), currentStmt, stmtIt, currentBlock);
@ -78,8 +79,19 @@ public class Pass1UnwindStructValues extends Pass1Base {
RValue structMemberVariable = memberUnwinding.getUnwinding(getScope());
getLog().append("Replacing struct member reference " + structMemberRef.toString(getProgram()) + " with member unwinding reference " + structMemberVariable.toString(getProgram()));
programValue.set(structMemberVariable);
modified.set(true);
}
*/
StructMemberRef structMemberRef = (StructMemberRef) programValue.get();
final ValueSource structValueSource = getValueSource(getProgram(), getScope(), structMemberRef.getStruct(), currentStmt, stmtIt, currentBlock);
if(structValueSource != null) {
final ValueSource memberUnwinding = structValueSource.getMemberUnwinding(structMemberRef.getMemberName(), getProgram(), getScope(), currentStmt, currentBlock, stmtIt);
RValue memberSimpleValue = memberUnwinding.getSimpleValue(getScope());
getLog().append("Replacing struct member reference " + structMemberRef.toString(getProgram()) + " with member unwinding reference " + memberSimpleValue.toString(getProgram()));
programValue.set(memberSimpleValue);
modified.set(true);
}
}
});
@ -210,10 +222,8 @@ public class Pass1UnwindStructValues extends Pass1Base {
boolean initialAssignment = assignment.isInitialAssignment();
StatementSource source = assignment.getSource();
// Check if this is already a bulk assignment
if(rValue instanceof MemcpyValue || rValue instanceof MemsetValue)
return false;
if(rValue instanceof StructUnwoundPlaceholder)
// Check if this is already a bulk assignment - or an unwound placeholder
if(rValue instanceof MemcpyValue || rValue instanceof MemsetValue || rValue instanceof StructUnwoundPlaceholder)
return false;
ValueSource lValueSource = getValueSource(getProgram(), getScope(), lValue, assignment, stmtIt, currentBlock);
@ -228,43 +238,6 @@ public class Pass1UnwindStructValues extends Pass1Base {
}
return true;
}
// Check for struct unwinding
if(1==1) throw new InternalError("E!");
StructUnwinding lValueUnwinding = getStructMemberUnwinding(lValue, assignment, stmtIt, currentBlock);
if(lValueUnwinding == null)
return false;
if(lValueUnwinding == POSTPONE_UNWINDING)
return true;
if(rValue instanceof StructUnwoundPlaceholder)
return false;
SymbolType rValueType = SymbolTypeInference.inferType(getScope(), rValue);
if(rValueType.equals(lValueStructType)) {
StructUnwinding rValueUnwinding = getStructMemberUnwinding(rValue, assignment, stmtIt, currentBlock);
if(rValueUnwinding == null) {
throw new CompileError("Incompatible struct assignment " + assignment.toString(getProgram(), false), assignment);
}
if(rValueUnwinding == POSTPONE_UNWINDING)
return true;
List<RValue> lValueUnwoundPlaceholder = new ArrayList<>();
for(String memberName : lValueUnwinding.getMemberNames()) {
/*
RValueUnwinding lValueMemberUnwinding = lValueUnwinding.getMemberUnwinding(memberName, getScope());
RValueUnwinding rValueMemberUnwinding = rValueUnwinding.getMemberUnwinding(memberName, getScope());
unwindAssignment(lValueMemberUnwinding, rValueMemberUnwinding, lValueUnwoundPlaceholder, stmtIt, initialAssignment, source);
*/
}
StructUnwoundPlaceholder unwoundPlaceholder = new StructUnwoundPlaceholder(lValueStructType, lValueUnwoundPlaceholder);
if(lValue instanceof VariableRef) {
assignment.setrValue2(unwoundPlaceholder);
} else {
stmtIt.remove();
}
return true;
}
throw new CompileError("Incompatible struct assignment " + assignment.toString(getProgram(), false), assignment);
}
return false;
}
@ -349,11 +322,8 @@ public class Pass1UnwindStructValues extends Pass1Base {
if(value instanceof StructMemberRef) {
final RValue structValue = ((StructMemberRef) value).getStruct();
final ValueSource structValueSource = getValueSource(program, programScope, structValue, currentStmt, stmtIt, currentBlock);
final ValueSource structMemberSource = structValueSource.getMemberUnwinding(((StructMemberRef) value).getMemberName(), program, programScope, currentStmt, currentBlock, stmtIt);
return structMemberSource;
return structValueSource.getMemberUnwinding(((StructMemberRef) value).getMemberName(), program, programScope, currentStmt, currentBlock, stmtIt);
}
return null;
}

39
src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceIndexed.java
View File

@ -76,14 +76,37 @@ public class ValueSourcePointerDereferenceIndexed extends ValueSourceBase {
// Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
final RValue structPointer = pointerDereferenceIndexed.getPointer();
if(structPointer instanceof ConstantValue) {
// Pointer to member type
ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
// Calculate member address (type*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((type*)&struct + OFFSET_MEMBER)
PointerDereferenceIndexed memberDeref = new PointerDereferenceIndexed(memberPointer, pointerDereferenceIndexed.getIndex());
return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, memberArraySpec);
if(memberArraySpec!=null) {
final SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
// Pointer to element type
ConstantCastValue elementTypedPointer = new ConstantCastValue(new SymbolTypePointer(elementType), (ConstantValue) structPointer);
// Calculate member address (elmType*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(elementTypedPointer, Operators.PLUS, memberOffsetConstant);
// Calculate member address (elmType*)&struct + OFFSET_MEMBER
if(pointerDereferenceIndexed.getIndex() instanceof ConstantValue) {
ConstantBinary elmPointer = new ConstantBinary(memberPointer, Operators.PLUS, (ConstantValue) pointerDereferenceIndexed.getIndex());
return new ValueSourceConstant(new SymbolTypePointer(elementType), null, elmPointer);
} else {
Scope scope = programScope.getScope(currentBlock.getScope());
Variable elementAddress = scope.addVariableIntermediate();
elementAddress.setType(new SymbolTypePointer(elementType));
stmtIt.previous();
stmtIt.add(new StatementAssignment((LValue) elementAddress.getRef(), memberPointer, Operators.PLUS, pointerDereferenceIndexed.getIndex(), true, currentStmt.getSource(), currentStmt.getComments()));
stmtIt.next();
return new ValueSourceVariable(elementAddress);
}
} else {
// Pointer to member type
ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
// Calculate member address (type*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((type*)&struct + OFFSET_MEMBER)
PointerDereferenceIndexed memberDeref = new PointerDereferenceIndexed(memberPointer, pointerDereferenceIndexed.getIndex());
return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, null);
}
} else {
if(memberArraySpec!=null)
throw new InternalError("Not implemented!");
Scope scope = programScope.getScope(currentBlock.getScope());
Variable memberAddress = scope.addVariableIntermediate();
memberAddress.setType(new SymbolTypePointer(memberType));
@ -94,7 +117,7 @@ public class ValueSourcePointerDereferenceIndexed extends ValueSourceBase {
stmtIt.next();
// Unwind to *((memberType*)ptr_struct+OFFSET_MEMBER)
PointerDereferenceIndexed memberDeref = new PointerDereferenceIndexed(memberAddress.getRef(), pointerDereferenceIndexed.getIndex());
return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, memberArraySpec);
return new ValueSourcePointerDereferenceIndexed(memberDeref, memberType, null);
}
}

62
src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourcePointerDereferenceSimple.java
View File

@ -69,25 +69,51 @@ public class ValueSourcePointerDereferenceSimple extends ValueSourceBase {
// Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
final RValue structPointer = pointerDereference.getPointer();
if(structPointer instanceof ConstantValue) {
// Pointer to member type
ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
// Calculate member address (type*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((type*)&struct + OFFSET_MEMBER)
PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
if(memberArraySpec!=null) {
SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
SymbolTypePointer pointerToElementType = new SymbolTypePointer(elementType);
// Pointer to member element type
ConstantCastValue structTypedPointer = new ConstantCastValue(pointerToElementType, (ConstantValue) structPointer);
// Calculate member address (elmtype*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((type*)&struct + OFFSET_MEMBER)
return new ValueSourceConstant(pointerToElementType, null, memberPointer);
} else {
// Pointer to member type
ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), (ConstantValue) structPointer);
// Calculate member address (memberType*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((memberType*)&struct + OFFSET_MEMBER)
PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, null);
}
} else {
Scope scope = programScope.getScope(currentBlock.getScope());
Variable memberAddress = scope.addVariableIntermediate();
memberAddress.setType(new SymbolTypePointer(memberType));
CastValue structTypedPointer = new CastValue(new SymbolTypePointer(memberType), structPointer);
// Add statement $1 = (memberType*)ptr_struct + OFFSET_MEMBER
stmtIt.previous();
stmtIt.add(new StatementAssignment((LValue) memberAddress.getRef(), structTypedPointer, Operators.PLUS, memberOffsetConstant, true, currentStmt.getSource(), currentStmt.getComments()));
stmtIt.next();
// Unwind to *((memberType*)ptr_struct+OFFSET_MEMBER)
PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberAddress.getRef());
return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
if(memberArraySpec!=null) {
SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
SymbolTypePointer pointerToElementType = new SymbolTypePointer(elementType);
Scope scope = programScope.getScope(currentBlock.getScope());
Variable memberAddress = scope.addVariableIntermediate();
memberAddress.setType(pointerToElementType);
CastValue elementTypedPointer = new CastValue(pointerToElementType, structPointer);
// Add statement $1 = (elmType*)ptr_struct + OFFSET_MEMBER
stmtIt.previous();
stmtIt.add(new StatementAssignment((LValue) memberAddress.getRef(), elementTypedPointer, Operators.PLUS, memberOffsetConstant, true, currentStmt.getSource(), currentStmt.getComments()));
stmtIt.next();
// Unwind to *((elmType*)ptr_struct+OFFSET_MEMBER)
return new ValueSourceVariable(memberAddress);
} else {
Scope scope = programScope.getScope(currentBlock.getScope());
Variable memberAddress = scope.addVariableIntermediate();
memberAddress.setType(new SymbolTypePointer(memberType));
CastValue structTypedPointer = new CastValue(new SymbolTypePointer(memberType), structPointer);
// Add statement $1 = (memberType*)ptr_struct + OFFSET_MEMBER
stmtIt.previous();
stmtIt.add(new StatementAssignment((LValue) memberAddress.getRef(), structTypedPointer, Operators.PLUS, memberOffsetConstant, true, currentStmt.getSource(), currentStmt.getComments()));
stmtIt.next();
// Unwind to *((memberType*)ptr_struct+OFFSET_MEMBER)
PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberAddress.getRef());
return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, null);
}
}
}
}

33
src/main/java/dk/camelot64/kickc/passes/unwinding/ValueSourceVariable.java
View File

@ -52,7 +52,7 @@ public class ValueSourceVariable extends ValueSourceBase {
@Override
public LValue getBulkLValue(ProgramScope scope) {
if(getArraySpec()!=null) {
if(getArraySpec() != null) {
return new PointerDereferenceSimple(variable.getRef());
} else {
ConstantSymbolPointer pointer = new ConstantSymbolPointer(variable.getRef());
@ -71,18 +71,29 @@ public class ValueSourceVariable extends ValueSourceBase {
public ValueSource getMemberUnwinding(String memberName, Program program, ProgramScope programScope, Statement currentStmt, ControlFlowBlock currentBlock, ListIterator<Statement> stmtIt) {
if(variable.isStructClassic()) {
StructDefinition structDefinition = ((SymbolTypeStruct) getSymbolType()).getStructDefinition(programScope);
final SymbolType memberType = structDefinition.getMember(memberName).getType();
final ArraySpec memberArraySpec = structDefinition.getMember(memberName).getArraySpec();
SymbolType memberType = structDefinition.getMember(memberName).getType();
ArraySpec memberArraySpec = structDefinition.getMember(memberName).getArraySpec();
ConstantRef memberOffsetConstant = PassNStructPointerRewriting.getMemberOffsetConstant(programScope, structDefinition, memberName);
// Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
ConstantSymbolPointer structPointer = new ConstantSymbolPointer(variable.getRef());
// Pointer to member type
ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), structPointer);
// Calculate member address (type*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((type*)&struct + OFFSET_MEMBER)
PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
if(memberArraySpec != null) {
// Pointer to member element type (elmtype*)&struct
SymbolType elementType = ((SymbolTypePointer) memberType).getElementType();
SymbolTypePointer pointerToElementType = new SymbolTypePointer(elementType);
ConstantCastValue structTypedPointer = new ConstantCastValue(pointerToElementType, structPointer);
// Calculate member address (elmtype*)&struct + OFFSET_MEMBER
ConstantBinary memberArrayPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to (elmtype*)&struct + OFFSET_MEMBER
return new ValueSourceConstant(pointerToElementType, null, memberArrayPointer);
} else {
// Simple member value - unwind to value of member *((type*)&struct + OFFSET_MEMBER)
// Pointer to member type
ConstantCastValue structTypedPointer = new ConstantCastValue(new SymbolTypePointer(memberType), structPointer);
// Calculate member address (type*)&struct + OFFSET_MEMBER
ConstantBinary memberPointer = new ConstantBinary(structTypedPointer, Operators.PLUS, memberOffsetConstant);
// Unwind to *((type*)&struct + OFFSET_MEMBER)
PointerDereferenceSimple memberDeref = new PointerDereferenceSimple(memberPointer);
return new ValueSourcePointerDereferenceSimple(memberDeref, memberType, memberArraySpec);
}
} else if(variable.isStructUnwind()) {
StructVariableMemberUnwinding structVariableMemberUnwinding = program.getStructVariableMemberUnwinding();
final StructVariableMemberUnwinding.VariableUnwinding variableUnwinding = structVariableMemberUnwinding.getVariableUnwinding(variable.getRef());

24
src/test/ref/complex/clearscreen/clearscreen.asm
View File

@ -208,8 +208,8 @@ startProcessing: {
.label spritePtr = $17
// Busy-wait while finding an empty slot in the PROCESSING array
.label freeIdx = 2
.label __35 = $e
.label __36 = $c
.label __34 = $e
.label __35 = $c
ldx #$ff
__b1:
lda #0
@ -241,19 +241,19 @@ startProcessing: {
sta.z __0+1
lda.z __0
asl
sta.z __35
sta.z __34
lda.z __0+1
rol
sta.z __35+1
asl.z __35
rol.z __35+1
lda.z __36
sta.z __34+1
asl.z __34
rol.z __34+1
lda.z __35
clc
adc.z __35
sta.z __36
lda.z __36+1
adc.z __35+1
sta.z __36+1
adc.z __34
sta.z __35
lda.z __35+1
adc.z __34+1
sta.z __35+1
asl.z __1
rol.z __1+1
asl.z __1

26
src/test/ref/complex/clearscreen/clearscreen.cfg
View File

@ -90,11 +90,11 @@ startProcessing::@1: scope:[startProcessing] from startProcessing startProcessi
to:startProcessing::@2
startProcessing::@2: scope:[startProcessing] from startProcessing::@1 startProcessing::@3
[46] (byte) startProcessing::i#2 ← phi( startProcessing::@1/(byte) 0 startProcessing::@3/(byte) startProcessing::i#1 )
[47] (byte~) startProcessing::$30 ← (byte) startProcessing::i#2 << (byte) 1
[48] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 + (byte) startProcessing::i#2
[49] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 << (byte) 1
[50] (byte~) startProcessing::$33 ← (byte~) startProcessing::$32 + (byte) startProcessing::i#2
[51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$33 << (byte) 1
[47] (byte~) startProcessing::$29 ← (byte) startProcessing::i#2 << (byte) 1
[48] (byte~) startProcessing::$30 ← (byte~) startProcessing::$29 + (byte) startProcessing::i#2
[49] (byte~) startProcessing::$31 ← (byte~) startProcessing::$30 << (byte) 1
[50] (byte~) startProcessing::$32 ← (byte~) startProcessing::$31 + (byte) startProcessing::i#2
[51] (byte~) startProcessing::$27 ← (byte~) startProcessing::$32 << (byte) 1
[52] if(*((byte*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_STATUS + (byte~) startProcessing::$27)!=(const byte) STATUS_FREE) goto startProcessing::@3
to:startProcessing::@4
startProcessing::@4: scope:[startProcessing] from startProcessing::@2 startProcessing::@9
@ -103,9 +103,9 @@ startProcessing::@4: scope:[startProcessing] from startProcessing::@2 startProc
to:startProcessing::@5
startProcessing::@5: scope:[startProcessing] from startProcessing::@4
[55] (word~) startProcessing::$0 ← (word)(byte) startProcessing::center_y#0
[56] (word~) startProcessing::$35 ← (word~) startProcessing::$0 << (byte) 2
[57] (word~) startProcessing::$36 ← (word~) startProcessing::$35 + (word~) startProcessing::$0
[58] (word~) startProcessing::$1 ← (word~) startProcessing::$36 << (byte) 3
[56] (word~) startProcessing::$34 ← (word~) startProcessing::$0 << (byte) 2
[57] (word~) startProcessing::$35 ← (word~) startProcessing::$34 + (word~) startProcessing::$0
[58] (word~) startProcessing::$1 ← (word~) startProcessing::$35 << (byte) 3
[59] (word) startProcessing::offset#0 ← (word~) startProcessing::$1 + (byte) startProcessing::center_x#0
[60] (byte*) startProcessing::colPtr#0 ← (const byte*) COLS + (word) startProcessing::offset#0
[61] (byte) startProcessing::spriteCol#0 ← *((byte*) startProcessing::colPtr#0)
@ -144,11 +144,11 @@ startProcessing::@7: scope:[startProcessing] from startProcessing::@6
[88] (byte) startProcessing::spritePtr#0 ← (byte)(const byte*) SPRITE_DATA/(byte) $40 + (byte) startProcessing::freeIdx#2
[89] (byte~) startProcessing::$20 ← (byte) startProcessing::freeIdx#2 << (byte) 3
[90] (word~) startProcessing::$21 ← (word)(byte~) startProcessing::$20
[91] (byte~) startProcessing::$38 ← (byte) startProcessing::freeIdx#2 << (byte) 1
[92] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 + (byte) startProcessing::freeIdx#2
[93] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 << (byte) 1
[94] (byte~) startProcessing::$41 ← (byte~) startProcessing::$40 + (byte) startProcessing::freeIdx#2
[95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$41 << (byte) 1
[91] (byte~) startProcessing::$37 ← (byte) startProcessing::freeIdx#2 << (byte) 1
[92] (byte~) startProcessing::$38 ← (byte~) startProcessing::$37 + (byte) startProcessing::freeIdx#2
[93] (byte~) startProcessing::$39 ← (byte~) startProcessing::$38 << (byte) 1
[94] (byte~) startProcessing::$40 ← (byte~) startProcessing::$39 + (byte) startProcessing::freeIdx#2
[95] (byte~) startProcessing::$28 ← (byte~) startProcessing::$40 << (byte) 1
[96] *((word*)(const struct ProcessingSprite*) PROCESSING + (byte~) startProcessing::$28) ← (word) startProcessing::spriteX#0
[97] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_Y + (byte~) startProcessing::$28) ← (word) startProcessing::spriteY#0
[98] *((word*)(const struct ProcessingSprite*) PROCESSING+(const byte) OFFSET_STRUCT_PROCESSINGSPRITE_VX + (byte~) startProcessing::$28) ← (word~) startProcessing::$21

640
src/test/ref/complex/clearscreen/clearscreen.log
View File

File diff suppressed because it is too large Load Diff

16
src/test/ref/complex/clearscreen/clearscreen.sym
View File

@ -404,16 +404,16 @@ interrupt(HARDWARE_ALL)(void()) irqTop()
(word~) startProcessing::$21 zp[2]:24 0.5
(byte~) startProcessing::$27 reg byte a 2002.0
(byte~) startProcessing::$28 reg byte x 2.2222222222222228
(byte~) startProcessing::$29 reg byte a 2002.0
(byte~) startProcessing::$30 reg byte a 2002.0
(byte~) startProcessing::$31 reg byte a 2002.0
(byte~) startProcessing::$32 reg byte a 2002.0
(byte~) startProcessing::$33 reg byte a 2002.0
(word~) startProcessing::$35 zp[2]:14 4.0
(word~) startProcessing::$36 zp[2]:12 4.0
(word~) startProcessing::$34 zp[2]:14 4.0
(word~) startProcessing::$35 zp[2]:12 4.0
(byte~) startProcessing::$37 reg byte a 4.0
(byte~) startProcessing::$38 reg byte a 4.0
(byte~) startProcessing::$39 reg byte a 4.0
(byte~) startProcessing::$40 reg byte a 4.0
(byte~) startProcessing::$41 reg byte a 4.0
(word~) startProcessing::$5 zp[2]:3 4.0
(word~) startProcessing::$6 zp[2]:3 4.0
(word~) startProcessing::$8 zp[2]:28 4.0
@ -495,13 +495,13 @@ reg byte x [ getCharToProcess::return_dist#0 ]
reg byte y [ main::center_x#0 ]
zp[1]:11 [ main::center_y#0 startProcessing::center_y#0 getCharToProcess::closest_y#7 getCharToProcess::closest_y#9 getCharToProcess::return_y#1 getCharToProcess::return_y#7 ]
reg byte a [ main::center_dist#0 ]
reg byte a [ startProcessing::$29 ]
reg byte a [ startProcessing::$30 ]
reg byte a [ startProcessing::$31 ]
reg byte a [ startProcessing::$32 ]
reg byte a [ startProcessing::$33 ]
reg byte a [ startProcessing::$27 ]
zp[2]:12 [ startProcessing::$0 startProcessing::$36 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
zp[2]:14 [ startProcessing::$35 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
zp[2]:12 [ startProcessing::$0 startProcessing::$35 startProcessing::$1 startProcessing::offset#0 startProcessing::screenPtr#0 atan2_16::yi#3 atan2_16::yi#8 atan2_16::yi#0 atan2_16::yi#16 atan2_16::$2 atan2_16::yi#1 atan2_16::yi#2 ]
zp[2]:14 [ startProcessing::$34 atan2_16::xi#3 atan2_16::xi#8 atan2_16::xi#0 atan2_16::xi#13 atan2_16::$7 atan2_16::xi#1 atan2_16::xi#2 ]
zp[2]:16 [ startProcessing::colPtr#0 atan2_16::angle#6 atan2_16::angle#12 atan2_16::angle#13 atan2_16::angle#2 atan2_16::angle#3 atan2_16::return#0 atan2_16::angle#5 atan2_16::angle#11 atan2_16::angle#1 atan2_16::angle#4 atan2_16::return#2 init_angle_screen::angle_w#0 init_angle_screen::$11 ]
zp[1]:18 [ startProcessing::spriteCol#0 init_angle_screen::x#2 init_angle_screen::x#1 getCharToProcess::closest_dist#2 getCharToProcess::closest_dist#8 getCharToProcess::closest_dist#10 getCharToProcess::closest_dist#12 ]
reg byte a [ startProcessing::ch#0 ]
@ -509,10 +509,10 @@ zp[2]:19 [ startProcessing::$11 startProcessing::$12 startProcessing::$13 startP
zp[2]:21 [ startProcessing::$15 startProcessing::$16 startProcessing::$17 startProcessing::spriteY#0 atan2_16::xd#5 atan2_16::xd#3 atan2_16::xd#10 atan2_16::xd#1 atan2_16::xd#2 ]
zp[1]:23 [ startProcessing::spritePtr#0 init_angle_screen::xb#2 init_angle_screen::xb#1 getCharToProcess::closest_x#7 getCharToProcess::closest_x#9 getCharToProcess::return_x#1 getCharToProcess::return_x#7 ]
reg byte a [ startProcessing::$20 ]
reg byte a [ startProcessing::$37 ]
reg byte a [ startProcessing::$38 ]
reg byte a [ startProcessing::$39 ]
reg byte a [ startProcessing::$40 ]
reg byte a [ startProcessing::$41 ]
reg byte x [ startProcessing::$28 ]
zp[2]:24 [ getCharToProcess::$8 getCharToProcess::$13 getCharToProcess::$9 getCharToProcess::$10 startProcessing::$21 heap_head#5 heap_head#1 init_angle_screen::screen_bottomline#6 init_angle_screen::screen_bottomline#0 init_angle_screen::screen_bottomline#1 init_angle_screen::screen#0 ]
reg byte a [ init_angle_screen::$3 ]

44
src/test/ref/complex/splines/truetype-splines.log
View File

@ -397,19 +397,17 @@ Replacing struct member reference (struct Segment) show_letter::segment.via with
Replacing struct member reference (struct Segment) show_letter::segment.to with member unwinding reference (struct SplineVector16) show_letter::segment_to
Replacing struct member reference (struct SplineVector16) show_letter::current.x with member unwinding reference (signed word) show_letter::current_x
Replacing struct member reference (struct SplineVector16) show_letter::current.y with member unwinding reference (signed word) show_letter::current_y
Replacing struct member reference (struct Segment) show_letter::segment.to with member unwinding reference (struct SplineVector16) show_letter::segment_to
Replacing struct member reference (struct Segment) show_letter::segment.to with member unwinding reference (struct SplineVector16) show_letter::segment_to
Replacing struct member reference (struct Segment) show_letter::segment.to.x with member unwinding reference (signed word) show_letter::segment_to_x
Replacing struct member reference (struct Segment) show_letter::segment.to.y with member unwinding reference (signed word) show_letter::segment_to_y
Replacing struct member reference (struct SplineVector16) bitmap_plot_spline_8seg::current.x with member unwinding reference (signed word) bitmap_plot_spline_8seg::current_x
Replacing struct member reference (struct SplineVector16) bitmap_plot_spline_8seg::current.y with member unwinding reference (signed word) bitmap_plot_spline_8seg::current_y
Replacing struct member reference *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$7).x with member unwinding reference *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
Replacing struct member reference *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$8).y with member unwinding reference *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8)
Replacing struct member reference (struct SplineVector16) rotate::vector.x with member unwinding reference (signed word) rotate::vector_x
Replacing struct member reference (struct SplineVector16) rotate::vector.y with member unwinding reference (signed word) rotate::vector_y
Replacing struct member reference (struct SplineVector16) rotate::vector.y with member unwinding reference (signed word) rotate::vector_y
Replacing struct member reference (struct SplineVector16) rotate::vector.x with member unwinding reference (signed word) rotate::vector_x
Converted procedure struct value parameter to member unwinding in call (void~) show_letter::$17 ← call spline_8segB (signed word) show_letter::current_x (signed word) show_letter::current_y (signed word) show_letter::segment_via_x (signed word) show_letter::segment_via_y (signed word) show_letter::segment_to_x (signed word) show_letter::segment_to_y
Replacing struct member reference (struct SplineVector16) show_letter::segment_to.x with member unwinding reference (signed word) show_letter::segment_to_x
Replacing struct member reference (struct SplineVector16) show_letter::segment_to.y with member unwinding reference (signed word) show_letter::segment_to_y
Rewriting struct pointer member access *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$7).x
Rewriting struct pointer member access *((const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$8).y
Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
Warning! Adding boolean cast to non-boolean condition (number~) abs_u16::$1
@ -1616,11 +1614,9 @@ bitmap_plot_spline_8seg::@1: scope:[bitmap_plot_spline_8seg] from bitmap_plot_s
(word~) bitmap_plot_spline_8seg::$0 ← ((word)) (signed word) bitmap_plot_spline_8seg::current_x#2
(word~) bitmap_plot_spline_8seg::$1 ← ((word)) (signed word) bitmap_plot_spline_8seg::current_y#2
(byte~) bitmap_plot_spline_8seg::$7 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
(signed word*~) bitmap_plot_spline_8seg::$10 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_X
(word~) bitmap_plot_spline_8seg::$2 ← ((word)) *((signed word*~) bitmap_plot_spline_8seg::$10 + (byte~) bitmap_plot_spline_8seg::$7)
(word~) bitmap_plot_spline_8seg::$2 ← ((word)) *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
(byte~) bitmap_plot_spline_8seg::$8 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
(signed word*~) bitmap_plot_spline_8seg::$11 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y
(word~) bitmap_plot_spline_8seg::$3 ← ((word)) *((signed word*~) bitmap_plot_spline_8seg::$11 + (byte~) bitmap_plot_spline_8seg::$8)
(word~) bitmap_plot_spline_8seg::$3 ← ((word)) *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8)
(word) bitmap_line::x1#1 ← (word~) bitmap_plot_spline_8seg::$0
(word) bitmap_line::y1#1 ← (word~) bitmap_plot_spline_8seg::$1
(word) bitmap_line::x2#1 ← (word~) bitmap_plot_spline_8seg::$2
@ -2151,8 +2147,6 @@ SYMBOL TABLE SSA
(void()) bitmap_plot_spline_8seg()
(word~) bitmap_plot_spline_8seg::$0
(word~) bitmap_plot_spline_8seg::$1
(signed word*~) bitmap_plot_spline_8seg::$10
(signed word*~) bitmap_plot_spline_8seg::$11
(word~) bitmap_plot_spline_8seg::$2
(word~) bitmap_plot_spline_8seg::$3
(bool~) bitmap_plot_spline_8seg::$5
@ -3026,8 +3020,8 @@ Inlining cast (word~) show_letter::$14 ← (word)(signed word) show_letter::segm
Inlining cast (word~) show_letter::$15 ← (word)(signed word) show_letter::segment_to_y#4
Inlining cast (word~) bitmap_plot_spline_8seg::$0 ← (word)(signed word) bitmap_plot_spline_8seg::current_x#2
Inlining cast (word~) bitmap_plot_spline_8seg::$1 ← (word)(signed word) bitmap_plot_spline_8seg::current_y#2
Inlining cast (word~) bitmap_plot_spline_8seg::$2 ← (word)*((signed word*~) bitmap_plot_spline_8seg::$10 + (byte~) bitmap_plot_spline_8seg::$7)
Inlining cast (word~) bitmap_plot_spline_8seg::$3 ← (word)*((signed word*~) bitmap_plot_spline_8seg::$11 + (byte~) bitmap_plot_spline_8seg::$8)
Inlining cast (word~) bitmap_plot_spline_8seg::$2 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
Inlining cast (word~) bitmap_plot_spline_8seg::$3 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8)
Inlining cast (signed word~) rotate::$0 ← (signed word)*((const signed byte*) COS + (byte) rotate::angle#2)
Inlining cast (signed word~) rotate::$2 ← (signed word)(signed dword~) rotate::$1
Inlining cast (signed word~) rotate::$5 ← (signed word)(signed dword~) rotate::$4
@ -3550,7 +3544,7 @@ Identical Phi Values (byte*) bitmap_screen#7 (byte*) bitmap_screen#1
Identical Phi Values (byte*) bitmap_gfx#12 (byte*) bitmap_gfx#1
Successful SSA optimization Pass2IdenticalPhiElimination
Identified duplicate assignment right side [107] (byte~) bitmap_init::$7 ← (byte) bitmap_init::y#2 & (byte) 7
Identified duplicate assignment right side [536] (byte~) bitmap_plot_spline_8seg::$8 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
Identified duplicate assignment right side [535] (byte~) bitmap_plot_spline_8seg::$8 ← (byte) bitmap_plot_spline_8seg::n#2 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) spline_8segB::$30 [48] if((byte) spline_8segB::n#1!=rangelast(0,7)) goto spline_8segB::@1
Simple Condition (bool~) memset::$1 [61] if((word) memset::num#2<=(byte) 0) goto memset::@1
@ -3578,15 +3572,13 @@ Simple Condition (bool~) main::$9 [421] if((byte) main::w#1!=rangelast(0,$3c)) g
Simple Condition (bool~) show_letter::$10 [488] if((byte) show_letter::segment_type#0==(const byte) MOVE_TO) goto show_letter::@2
Simple Condition (bool~) show_letter::$11 [494] if((byte) show_letter::segment_type#0==(const byte) SPLINE_TO) goto show_letter::@3
Simple Condition (bool~) show_letter::$19 [524] if((byte) show_letter::i#1!=rangelast(0,$15)) goto show_letter::@1
Simple Condition (bool~) bitmap_plot_spline_8seg::$5 [550] if((byte) bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1
Simple Condition (bool~) bitmap_plot_spline_8seg::$5 [548] if((byte) bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Rewriting ! if()-condition to reversed if() [167] (bool~) bitmap_line::$7 ← ! (bool~) bitmap_line::$6
Rewriting && if()-condition to two if()s [166] (bool~) bitmap_line::$6 ← (bool~) bitmap_line::$4 && (bool~) bitmap_line::$5
Successful SSA optimization Pass2ConditionalAndOrRewriting
Constant right-side identified [54] (byte~) spline_8segB::$32 ← (byte) 8 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
Constant right-side identified [526] (byte~) bitmap_plot_spline_8seg::$6 ← (byte) 0 * (const byte) SIZEOF_STRUCT_SPLINEVECTOR16
Constant right-side identified [534] (signed word*~) bitmap_plot_spline_8seg::$10 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_X
Constant right-side identified [537] (signed word*~) bitmap_plot_spline_8seg::$11 ← (signed word*)(const struct SplineVector16*) SPLINE_8SEG + (const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) spline_8segB::n#0 = 0
Constant (const byte) spline_8segB::$32 = 8*SIZEOF_STRUCT_SPLINEVECTOR16
@ -3627,8 +3619,6 @@ Constant (const signed word) show_letter::current_y#0 = 0
Constant (const byte) show_letter::i#0 = 0
Constant (const byte) bitmap_plot_spline_8seg::$6 = 0*SIZEOF_STRUCT_SPLINEVECTOR16
Constant (const byte) bitmap_plot_spline_8seg::n#0 = 1
Constant (const signed word*) bitmap_plot_spline_8seg::$10 = (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_X
Constant (const signed word*) bitmap_plot_spline_8seg::$11 = (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_Y
Successful SSA optimization Pass2ConstantIdentification
Constant (const byte*) bitmap_gfx#1 = bitmap_init::gfx#0
Constant (const byte*) bitmap_screen#1 = bitmap_init::screen#0
@ -3652,11 +3642,10 @@ Resolved ranged next value [419] main::w#1 ← ++ main::w#4 to ++
Resolved ranged comparison value [421] if(main::w#1!=rangelast(0,$3c)) goto main::@5 to (number) $3d
Resolved ranged next value [522] show_letter::i#1 ← ++ show_letter::i#10 to ++
Resolved ranged comparison value [524] if(show_letter::i#1!=rangelast(0,$15)) goto show_letter::@1 to (number) $16
Resolved ranged next value [548] bitmap_plot_spline_8seg::n#1 ← ++ bitmap_plot_spline_8seg::n#2 to ++
Resolved ranged comparison value [550] if(bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1 to (number) 9
Resolved ranged next value [546] bitmap_plot_spline_8seg::n#1 ← ++ bitmap_plot_spline_8seg::n#2 to ++
Resolved ranged comparison value [548] if(bitmap_plot_spline_8seg::n#1!=rangelast(1,8)) goto bitmap_plot_spline_8seg::@1 to (number) 9
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_SPLINEVECTOR16 in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero (signed word*)SPLINE_8SEG in
Simplifying expression containing zero (signed word*)SPLINE_8SEG in [36] *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) spline_8segB::$31) ← (signed word~) spline_8segB::$23
Simplifying expression containing zero (signed word*)SPLINE_8SEG in [55] *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (const byte) spline_8segB::$32) ← (signed word~) spline_8segB::$19
Simplifying expression containing zero (signed word*)(struct SplineVector16*)letter_c+OFFSET_STRUCT_SEGMENT_TO in [438] (signed word) show_letter::to_x#0 ← *((signed word*)(struct SplineVector16*)(const struct Segment*) letter_c+(const byte) OFFSET_STRUCT_SEGMENT_TO+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) show_letter::$20)
@ -3665,7 +3654,8 @@ Simplifying expression containing zero (byte*)letter_c in [482] (byte) show_lett
Simplifying expression containing zero (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_X in [527] (signed word) bitmap_plot_spline_8seg::current_x#0 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (const byte) bitmap_plot_spline_8seg::$6)
Simplifying expression containing zero (signed word*)SPLINE_8SEG in [527] (signed word) bitmap_plot_spline_8seg::current_x#0 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X)
Simplifying expression containing zero (signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_Y in [528] (signed word) bitmap_plot_spline_8seg::current_y#0 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (const byte) bitmap_plot_spline_8seg::$6)
Simplifying expression containing zero (signed word*)SPLINE_8SEG in [546] (signed word) bitmap_plot_spline_8seg::current_x#1 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$9)
Simplifying expression containing zero (signed word*)SPLINE_8SEG in [534] (word) bitmap_line::x2#1 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$7)
Simplifying expression containing zero (signed word*)SPLINE_8SEG in [544] (signed word) bitmap_plot_spline_8seg::current_x#1 ← *((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_X + (byte~) bitmap_plot_spline_8seg::$9)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (void*) memset::return#2 and assignment [75] (void*) memset::return#2 ← (void*) memset::str#3
Eliminating unused variable (void*) memset::return#3 and assignment [77] (void*) memset::return#3 ← (void*) memset::str#3
@ -3746,8 +3736,8 @@ Inlining Noop Cast [41] (byte*~) memset::$2 ← (byte*)(void*) memset::str#3 kee
Inlining Noop Cast [43] (byte*) memset::dst#0 ← (byte*)(void*) memset::str#3 keeping memset::str#3
Inlining Noop Cast [190] (word~) mulf16s::$10 ← (word)(signed word) mulf16s::b#4 keeping mulf16s::b#4
Inlining Noop Cast [196] (word~) mulf16s::$14 ← (word)(signed word) mulf16s::a#4 keeping mulf16s::a#4
Inlining Noop Cast [274] (word) bitmap_line::x2#1 ← (word)*((const signed word*) bitmap_plot_spline_8seg::$10 + (byte~) bitmap_plot_spline_8seg::$8) keeping *(bitmap_plot_spline_8seg::$10 + bitmap_plot_spline_8seg::$8)
Inlining Noop Cast [275] (word) bitmap_line::y2#1 ← (word)*((const signed word*) bitmap_plot_spline_8seg::$11 + (byte~) bitmap_plot_spline_8seg::$8) keeping *(bitmap_plot_spline_8seg::$11 + bitmap_plot_spline_8seg::$8)
Inlining Noop Cast [274] (word) bitmap_line::x2#1 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG + (byte~) bitmap_plot_spline_8seg::$8) keeping *((signed word*)SPLINE_8SEG + bitmap_plot_spline_8seg::$8)
Inlining Noop Cast [275] (word) bitmap_line::y2#1 ← (word)*((signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y + (byte~) bitmap_plot_spline_8seg::$8) keeping *((signed word*)SPLINE_8SEG+OFFSET_STRUCT_SPLINEVECTOR16_Y + bitmap_plot_spline_8seg::$8)
Successful SSA optimization Pass2NopCastInlining
Inlining Noop Cast [78] (byte*) bitmap_plot::plotter#0 ← (byte*)(word~) bitmap_plot::$3 keeping bitmap_plot::plotter#0
Inlining Noop Cast [317] (signed byte~) rotate::$15 ← (signed byte)(byte~) rotate::$14 keeping rotate::$15
@ -3842,8 +3832,6 @@ Constant inlined mulf_init::sqr1_lo#0 = (const byte*) mulf_sqr1_lo+(byte) 1
Constant inlined spline_8segB::n#0 = (byte) 0
Constant inlined bitmap_init::x#0 = (byte) 0
Constant inlined memset::c#1 = (byte) 0
Constant inlined bitmap_plot_spline_8seg::$10 = (signed word*)(const struct SplineVector16*) SPLINE_8SEG
Constant inlined bitmap_plot_spline_8seg::$11 = (signed word*)(const struct SplineVector16*) SPLINE_8SEG+(const byte) OFFSET_STRUCT_SPLINEVECTOR16_Y
Constant inlined mulf_init::c#0 = (byte) 0
Constant inlined main::toD0181_screen#0 = (const byte*) BITMAP_SCREEN
Constant inlined main::toD0181_gfx#0 = (const byte*) BITMAP_GRAPHICS

4
src/test/ref/declared-memory-var-3.log
View File

@ -1,6 +1,6 @@
Setting inferred volatile on symbol affected by address-of (struct foo*) main::barp ← &(struct foo) bar
Rewriting struct pointer member access *((struct foo*) main::barp).thing1
Rewriting struct pointer member access *((struct foo*) main::barp).thing2
Replacing struct member reference *((struct foo*) main::barp).thing1 with member unwinding reference *((byte*~) main::$0)
Replacing struct member reference *((struct foo*) main::barp).thing2 with member unwinding reference *((byte*~) main::$1)
Identified constant variable (struct foo*) main::barp
CONTROL FLOW GRAPH SSA

6
src/test/ref/declared-memory-var-4.log
View File

@ -3,9 +3,9 @@ Fixing struct type size struct foo to 14
Fixing struct type SIZE_OF struct foo to 14
Fixing struct type SIZE_OF struct foo to 14
Setting inferred volatile on symbol affected by address-of (struct foo*) main::barp ← &(struct foo) bar
Rewriting struct pointer member access *((struct foo*) main::barp).thing1
Rewriting struct pointer member access *((struct foo*) main::barp).thing2
Rewriting struct pointer member access *((struct foo*) main::barp).thing3
Replacing struct member reference *((struct foo*) main::barp).thing1 with member unwinding reference *((byte*~) main::$1)
Replacing struct member reference *((struct foo*) main::barp).thing2 with member unwinding reference *((byte*~) main::$2)
Replacing struct member reference *((struct foo*) main::barp).thing3 with member unwinding reference (byte*~) main::$3
Identified constant variable (struct foo*) main::barp
Culled Empty Block (label) main::@2

29
src/test/ref/initializer-2.log
View File

@ -1,7 +1,7 @@
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$1).x
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$2).y
Replacing struct member reference *((const struct Point*) points + (byte~) main::$1).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$1)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$2).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$2)
Culled Empty Block (label) main::@2
CONTROL FLOW GRAPH SSA
@ -17,12 +17,10 @@ main::@1: scope:[main] from main main::@1
(byte) main::idx#3 ← phi( main/(byte) main::idx#0 main::@1/(byte) main::idx#2 )
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$1 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$3 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) main::SCREEN + (byte) main::idx#3) ← *((byte*~) main::$3 + (byte~) main::$1)
*((const byte*) main::SCREEN + (byte) main::idx#3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$1)
(byte) main::idx#1 ← ++ (byte) main::idx#3
(byte~) main::$2 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*~) main::$4 + (byte~) main::$2)
*((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$2)
(byte) main::idx#2 ← ++ (byte) main::idx#1
(byte) main::i#1 ← (byte) main::i#2 + rangenext(0,2)
(bool~) main::$0 ← (byte) main::i#1 != rangelast(0,2)
@ -52,8 +50,6 @@ SYMBOL TABLE SSA
(bool~) main::$0
(byte~) main::$1
(byte~) main::$2
(byte*~) main::$3
(byte*~) main::$4
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*)(number) $400
@ -70,21 +66,16 @@ SYMBOL TABLE SSA
Simplifying constant pointer cast (byte*) 1024
Successful SSA optimization PassNCastSimplification
Identified duplicate assignment right side [7] (byte~) main::$2 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [6] (byte~) main::$2 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) main::$0 [13] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
Simple Condition (bool~) main::$0 [11] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [4] (byte*~) main::$3 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [8] (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::idx#0 = 0
Constant (const byte) main::i#0 = 0
Constant (const byte*) main::$3 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$4 = (byte*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [11] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [13] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
Simplifying expression containing zero (byte*)points in
Resolved ranged next value [9] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [11] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
Simplifying expression containing zero (byte*)points in [4] *((const byte*) main::SCREEN + (byte) main::idx#3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$1)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
@ -102,8 +93,6 @@ Inlining constant with var siblings (const byte) main::idx#0
Inlining constant with var siblings (const byte) main::i#0
Constant inlined main::i#0 = (byte) 0
Constant inlined main::idx#0 = (byte) 0
Constant inlined main::$3 = (byte*)(const struct Point*) points
Constant inlined main::$4 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantInlining
Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization PassNEliminateUnusedVars

4
src/test/ref/initializer-3.cfg
View File

@ -15,8 +15,8 @@ main: scope:[main] from @1
main::@1: scope:[main] from main main::@1
[5] (byte) main::idx#4 ← phi( main/(byte) 0 main::@1/(byte) main::idx#3 )
[5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
[6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1
[7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2
[6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1
[7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2
[8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4)
[9] (byte) main::idx#1 ← ++ (byte) main::idx#4
[10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)

90
src/test/ref/initializer-3.log
View File

@ -1,9 +1,9 @@
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$3).x
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$4).y
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$5).y
Replacing struct member reference *((const struct Point*) points + (byte~) main::$3).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$4).y with member unwinding reference *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$5).y with member unwinding reference *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5)
Culled Empty Block (label) main::@2
CONTROL FLOW GRAPH SSA
@ -19,17 +19,14 @@ main::@1: scope:[main] from main main::@1
(byte) main::idx#4 ← phi( main/(byte) main::idx#0 main::@1/(byte) main::idx#3 )
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$3 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*~) main::$6 + (byte~) main::$3)
*((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
(byte) main::idx#1 ← ++ (byte) main::idx#4
(byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(signed word*~) main::$7 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
(byte~) main::$0 ← < *((signed word*~) main::$7 + (byte~) main::$4)
(byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
*((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte~) main::$0
(byte) main::idx#2 ← ++ (byte) main::idx#1
(byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(signed word*~) main::$8 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
(byte~) main::$1 ← > *((signed word*~) main::$8 + (byte~) main::$5)
(byte~) main::$1 ← > *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5)
*((const byte*) main::SCREEN + (byte) main::idx#2) ← (byte~) main::$1
(byte) main::idx#3 ← ++ (byte) main::idx#2
(byte) main::i#1 ← (byte) main::i#2 + rangenext(0,2)
@ -63,9 +60,6 @@ SYMBOL TABLE SSA
(byte~) main::$3
(byte~) main::$4
(byte~) main::$5
(byte*~) main::$6
(signed word*~) main::$7
(signed word*~) main::$8
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*)(number) $400
@ -83,24 +77,17 @@ SYMBOL TABLE SSA
Simplifying constant pointer cast (byte*) 1024
Successful SSA optimization PassNCastSimplification
Identified duplicate assignment right side [7] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [12] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [6] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [10] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) main::$2 [19] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
Simple Condition (bool~) main::$2 [16] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [4] (byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [8] (signed word*~) main::$7 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [13] (signed word*~) main::$8 ← (signed word*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::idx#0 = 0
Constant (const byte) main::i#0 = 0
Constant (const byte*) main::$6 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const signed word*) main::$7 = (signed word*)points+OFFSET_STRUCT_POINT_Y
Constant (const signed word*) main::$8 = (signed word*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [17] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [19] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
Simplifying expression containing zero (byte*)points in
Resolved ranged next value [14] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [16] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
Simplifying expression containing zero (byte*)points in [4] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
@ -116,12 +103,9 @@ Rewriting multiplication to use shift and addition[1] (byte~) main::$4 ← (byte
Inlining constant with var siblings (const byte) main::idx#0
Inlining constant with var siblings (const byte) main::i#0
Constant inlined main::i#0 = (byte) 0
Constant inlined main::$6 = (byte*)(const struct Point*) points
Constant inlined main::idx#0 = (byte) 0
Constant inlined main::$7 = (signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$8 = (signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantInlining
Alias (byte~) main::$4 = (byte~) main::$10
Alias (byte~) main::$4 = (byte~) main::$7
Successful SSA optimization Pass2AliasElimination
Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization PassNEliminateUnusedVars
@ -163,8 +147,8 @@ main: scope:[main] from @1
main::@1: scope:[main] from main main::@1
[5] (byte) main::idx#4 ← phi( main/(byte) 0 main::@1/(byte) main::idx#3 )
[5] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
[6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1
[7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2
[6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1
[7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2
[8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4)
[9] (byte) main::idx#1 ← ++ (byte) main::idx#4
[10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
@ -188,7 +172,7 @@ VARIABLE REGISTER WEIGHTS
(byte~) main::$0 22.0
(byte~) main::$1 22.0
(byte~) main::$4 7.333333333333333
(byte~) main::$9 22.0
(byte~) main::$6 22.0
(byte) main::i
(byte) main::i#1 16.5
(byte) main::i#2 4.0
@ -201,7 +185,7 @@ VARIABLE REGISTER WEIGHTS
Initial phi equivalence classes
[ main::i#2 main::i#1 ]
[ main::idx#4 main::idx#3 ]
Added variable main::$9 to live range equivalence class [ main::$9 ]
Added variable main::$6 to live range equivalence class [ main::$6 ]
Added variable main::$4 to live range equivalence class [ main::$4 ]
Added variable main::idx#1 to live range equivalence class [ main::idx#1 ]
Added variable main::$0 to live range equivalence class [ main::$0 ]
@ -210,7 +194,7 @@ Added variable main::$1 to live range equivalence class [ main::$1 ]
Complete equivalence classes
[ main::i#2 main::i#1 ]
[ main::idx#4 main::idx#3 ]
[ main::$9 ]
[ main::$6 ]
[ main::$4 ]
[ main::idx#1 ]
[ main::$0 ]
@ -218,7 +202,7 @@ Complete equivalence classes
[ main::$1 ]
Allocated zp[1]:2 [ main::i#2 main::i#1 ]
Allocated zp[1]:3 [ main::idx#4 main::idx#3 ]
Allocated zp[1]:4 [ main::$9 ]
Allocated zp[1]:4 [ main::$6 ]
Allocated zp[1]:5 [ main::$4 ]
Allocated zp[1]:6 [ main::idx#1 ]
Allocated zp[1]:7 [ main::$0 ]
@ -262,7 +246,7 @@ main: {
.label idx_1 = 8
.label idx_2 = 3
.label i = 2
.label __9 = 4
.label __6 = 4
// [5] phi from main to main::@1 [phi:main->main::@1]
__b1_from_main:
// [5] phi (byte) main::idx#4 = (byte) 0 [phi:main->main::@1#0] -- vbuz1=vbuc1
@ -279,12 +263,12 @@ main: {
jmp __b1
// main::@1
__b1:
// [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1
// [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 -- vbuz1=vbuz2_rol_1
lda.z i
asl
sta.z __9
// [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 -- vbuz1=vbuz2_plus_vbuz3
lda.z __9
sta.z __6
// [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 -- vbuz1=vbuz2_plus_vbuz3
lda.z __6
clc
adc.z i
sta.z __4
@ -342,24 +326,24 @@ main: {
.word 6
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$9 ] ( main:2 [ main::i#2 main::idx#4 main::$9 ] ) always clobbers reg byte a
Statement [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$6 ] ( main:2 [ main::i#2 main::idx#4 main::$6 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp[1]:2 [ main::i#2 main::i#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:3 [ main::idx#4 main::idx#3 ]
Statement [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a
Statement [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a
Statement [8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4) [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp[1]:5 [ main::$4 ]
Statement [10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::$4 main::idx#1 main::$0 ] ( main:2 [ main::i#2 main::$4 main::idx#1 main::$0 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp[1]:6 [ main::idx#1 ]
Statement [13] (byte~) main::$1 ← > *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::idx#2 main::$1 ] ( main:2 [ main::i#2 main::idx#2 main::$1 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp[1]:8 [ main::idx#2 ]
Statement [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$9 ] ( main:2 [ main::i#2 main::idx#4 main::$9 ] ) always clobbers reg byte a
Statement [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a
Statement [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 [ main::i#2 main::idx#4 main::$6 ] ( main:2 [ main::i#2 main::idx#4 main::$6 ] ) always clobbers reg byte a
Statement [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a
Statement [8] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points + (byte~) main::$4) [ main::i#2 main::idx#4 main::$4 ] ( main:2 [ main::i#2 main::idx#4 main::$4 ] ) always clobbers reg byte a
Statement [10] (byte~) main::$0 ← < *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::$4 main::idx#1 main::$0 ] ( main:2 [ main::i#2 main::$4 main::idx#1 main::$0 ] ) always clobbers reg byte a
Statement [13] (byte~) main::$1 ← > *((signed word*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) [ main::i#2 main::idx#2 main::$1 ] ( main:2 [ main::i#2 main::idx#2 main::$1 ] ) always clobbers reg byte a
Potential registers zp[1]:2 [ main::i#2 main::i#1 ] : zp[1]:2 , reg byte x , reg byte y ,
Potential registers zp[1]:3 [ main::idx#4 main::idx#3 ] : zp[1]:3 , reg byte x , reg byte y ,
Potential registers zp[1]:4 [ main::$9 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:4 [ main::$6 ] : zp[1]:4 , reg byte a , reg byte x , reg byte y ,
Potential registers zp[1]:5 [ main::$4 ] : zp[1]:5 , reg byte x , reg byte y ,
Potential registers zp[1]:6 [ main::idx#1 ] : zp[1]:6 , reg byte x , reg byte y ,
Potential registers zp[1]:7 [ main::$0 ] : zp[1]:7 , reg byte a , reg byte x , reg byte y ,
@ -367,11 +351,11 @@ Potential registers zp[1]:8 [ main::idx#2 ] : zp[1]:8 , reg byte x , reg byte y
Potential registers zp[1]:9 [ main::$1 ] : zp[1]:9 , reg byte a , reg byte x , reg byte y ,
REGISTER UPLIFT SCOPES
Uplift Scope [main] 22: zp[1]:4 [ main::$9 ] 22: zp[1]:7 [ main::$0 ] 22: zp[1]:9 [ main::$1 ] 20.5: zp[1]:2 [ main::i#2 main::i#1 ] 15.58: zp[1]:3 [ main::idx#4 main::idx#3 ] 11: zp[1]:6 [ main::idx#1 ] 11: zp[1]:8 [ main::idx#2 ] 7.33: zp[1]:5 [ main::$4 ]
Uplift Scope [main] 22: zp[1]:4 [ main::$6 ] 22: zp[1]:7 [ main::$0 ] 22: zp[1]:9 [ main::$1 ] 20.5: zp[1]:2 [ main::i#2 main::i#1 ] 15.58: zp[1]:3 [ main::idx#4 main::idx#3 ] 11: zp[1]:6 [ main::idx#1 ] 11: zp[1]:8 [ main::idx#2 ] 7.33: zp[1]:5 [ main::$4 ]
Uplift Scope [Point]
Uplift Scope []
Uplifting [main] best 1098 combination reg byte a [ main::$9 ] reg byte a [ main::$0 ] reg byte a [ main::$1 ] reg byte x [ main::i#2 main::i#1 ] zp[1]:3 [ main::idx#4 main::idx#3 ] zp[1]:6 [ main::idx#1 ] zp[1]:8 [ main::idx#2 ] zp[1]:5 [ main::$4 ]
Uplifting [main] best 1098 combination reg byte a [ main::$6 ] reg byte a [ main::$0 ] reg byte a [ main::$1 ] reg byte x [ main::i#2 main::i#1 ] zp[1]:3 [ main::idx#4 main::idx#3 ] zp[1]:6 [ main::idx#1 ] zp[1]:8 [ main::idx#2 ] zp[1]:5 [ main::$4 ]
Limited combination testing to 100 combinations of 15552 possible.
Uplifting [Point] best 1098 combination
Uplifting [] best 1098 combination
@ -434,10 +418,10 @@ main: {
jmp __b1
// main::@1
__b1:
// [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1
// [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1
txa
asl
// [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx
// [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx
stx.z $ff
clc
adc.z $ff
@ -523,7 +507,7 @@ FINAL SYMBOL TABLE
(byte~) main::$0 reg byte a 22.0
(byte~) main::$1 reg byte a 22.0
(byte~) main::$4 zp[1]:3 7.333333333333333
(byte~) main::$9 reg byte a 22.0
(byte~) main::$6 reg byte a 22.0
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*) 1024
@ -539,7 +523,7 @@ FINAL SYMBOL TABLE
reg byte x [ main::i#2 main::i#1 ]
zp[1]:2 [ main::idx#4 main::idx#3 main::idx#1 main::idx#2 ]
reg byte a [ main::$9 ]
reg byte a [ main::$6 ]
zp[1]:3 [ main::$4 ]
reg byte a [ main::$0 ]
reg byte a [ main::$1 ]
@ -581,10 +565,10 @@ main: {
// main::@1
__b1:
// SCREEN[idx++] = points[i].x
// [6] (byte~) main::$9 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1
// [6] (byte~) main::$6 ← (byte) main::i#2 << (byte) 1 -- vbuaa=vbuxx_rol_1
txa
asl
// [7] (byte~) main::$4 ← (byte~) main::$9 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx
// [7] (byte~) main::$4 ← (byte~) main::$6 + (byte) main::i#2 -- vbuz1=vbuaa_plus_vbuxx
stx.z $ff
clc
adc.z $ff

4
src/test/ref/initializer-3.sym
View File

@ -8,7 +8,7 @@
(byte~) main::$0 reg byte a 22.0
(byte~) main::$1 reg byte a 22.0
(byte~) main::$4 zp[1]:3 7.333333333333333
(byte~) main::$9 reg byte a 22.0
(byte~) main::$6 reg byte a 22.0
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*) 1024
@ -24,7 +24,7 @@
reg byte x [ main::i#2 main::i#1 ]
zp[1]:2 [ main::idx#4 main::idx#3 main::idx#1 main::idx#2 ]
reg byte a [ main::$9 ]
reg byte a [ main::$6 ]
zp[1]:3 [ main::$4 ]
reg byte a [ main::$0 ]
reg byte a [ main::$1 ]

8
src/test/ref/millfork-benchmarks/linkedlist-kc.log
View File

@ -8,10 +8,10 @@ Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items -
Fixing pointer addition (struct node*~) alloc::$0 ← (const struct node*) heap + (word) free_
Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
Rewriting struct pointer member access *((struct node*) prepend::new).next
Rewriting struct pointer member access *((struct node*) prepend::new).value
Rewriting struct pointer member access *((struct node*) sum::current).value
Rewriting struct pointer member access *((struct node*) sum::current).next
Replacing struct member reference *((struct node*) prepend::new).next with member unwinding reference *((struct node**~) prepend::$1)
Replacing struct member reference *((struct node*) prepend::new).value with member unwinding reference *((word*~) prepend::$2)
Replacing struct member reference *((struct node*) sum::current).value with member unwinding reference *((word*~) sum::$0)
Replacing struct member reference *((struct node*) sum::current).next with member unwinding reference *((struct node**~) sum::$1)
Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)

2
src/test/ref/parse-negated-struct-ref.log
View File

@ -1,5 +1,5 @@
Setting inferred volatile on symbol affected by address-of (struct A*) main::a ← &(struct A) aa
Rewriting struct pointer member access *((struct A*) main::a).b
Replacing struct member reference *((struct A*) main::a).b with member unwinding reference *((byte*~) main::$2)
Warning! Adding boolean cast to non-boolean sub-expression *((byte*~) main::$2)
Identified constant variable (struct A*) main::a

69
src/test/ref/struct-14.log
View File

@ -2,10 +2,10 @@ Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$0).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$1).y
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$2).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$3).y
Replacing struct member reference *((const struct Point*) points + (number~) main::$0).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0)
Replacing struct member reference *((const struct Point*) points + (number~) main::$1).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1)
Replacing struct member reference *((const struct Point*) points + (number~) main::$2).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
Replacing struct member reference *((const struct Point*) points + (number~) main::$3).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -14,17 +14,13 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @1
(number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$4 + (number~) main::$0) ← (number) 2
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0) ← (number) 2
(number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$5 + (number~) main::$1) ← (number) 3
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1) ← (number) 3
(number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$6 + (number~) main::$2)
*((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
(number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$7 + (number~) main::$3)
*((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
to:main::@return
main::@return: scope:[main] from main
return
@ -52,28 +48,24 @@ SYMBOL TABLE SSA
(number~) main::$1
(number~) main::$2
(number~) main::$3
(byte*~) main::$4
(byte*~) main::$5
(byte*~) main::$6
(byte*~) main::$7
(label) main::@return
(const struct Point*) points[(number) 1] = { fill( 1, 0) }
Adding number conversion cast (unumber) 0 in (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 2 in *((byte*~) main::$4 + (unumber~) main::$0) ← (number) 2
Adding number conversion cast (unumber) 2 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (number) 2
Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 3 in *((byte*~) main::$5 + (unumber~) main::$1) ← (number) 3
Adding number conversion cast (unumber) 3 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (number) 3
Adding number conversion cast (unumber) 0 in (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$6 + (unumber~) main::$2)
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2)
Adding number conversion cast (unumber) 0 in (number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$7 + (unumber~) main::$3)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3)
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast *((byte*~) main::$4 + (unumber~) main::$0) ← (unumber)(number) 2
Inlining cast *((byte*~) main::$5 + (unumber~) main::$1) ← (unumber)(number) 3
Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (unumber)(number) 2
Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (unumber)(number) 3
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -99,35 +91,27 @@ Inferred type updated to byte in (unumber~) main::$1 ← (byte) 0 * (const byte)
Inferred type updated to byte in (unumber~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Inferred type updated to byte in (unumber~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [0] (byte~) main::$0 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [1] (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [3] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [4] (byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [6] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [7] (byte*~) main::$6 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [9] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [10] (byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [2] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [6] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$0 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$4 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$1 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$5 = (byte*)points+OFFSET_STRUCT_POINT_Y
Constant (const byte) main::$2 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$6 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$3 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$7 = (byte*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero main::$4 in [2] *((const byte*) main::$4 + (const byte) main::$0) ← (byte) 2
Simplifying expression containing zero main::$5 in [5] *((const byte*) main::$5 + (const byte) main::$1) ← (byte) 3
Simplifying expression containing zero main::$6 in [8] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$6 + (const byte) main::$2)
Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$6)
Simplifying expression containing zero main::$7 in [11] *((const byte*) SCREEN + (byte) 1) ← *((const byte*) main::$7 + (const byte) main::$3)
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$0) ← (byte) 2
Simplifying expression containing zero (byte*)points in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [3] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$1) ← (byte) 3
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [5] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$2)
Simplifying expression containing zero (byte*)points in [5] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero SCREEN in [5] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points)
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [7] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$3)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) main::$0
Eliminating unused constant (const byte) main::$1
@ -136,11 +120,6 @@ Eliminating unused constant (const byte) main::$3
Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$5 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$6 = (byte*)(const struct Point*) points
Constant inlined main::$4 = (byte*)(const struct Point*) points
Constant inlined main::$7 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+1)
Successful SSA optimization Pass2ConstantAdditionElimination
Adding NOP phi() at start of @begin

2
src/test/ref/struct-17.asm
View File

@ -4,8 +4,8 @@
.pc = $80d "Program"
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
main: {
.label v = 2
ldy #SIZEOF_STRUCT_VECTOR

131
src/test/ref/struct-17.log
View File

@ -1,20 +1,12 @@
Adding value bulk copy *(&(struct Vector) main::v) ← memset(struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -24,22 +16,14 @@ CONTROL FLOW GRAPH SSA
main: scope:[main] from @1
*(&(struct Vector) main::v) ← memset(struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
(struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
(byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$0) ← (number) 2
(byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$1) ← (number) 3
(byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$2) ← (number) 4
(byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$3) ← (number) 5
(byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4)
(byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5)
(byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$6)
(byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$7)
*((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 2
*((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 3
*((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 4
*((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 5
*((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
*((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
to:main::@return
main::@return: scope:[main] from main
return
@ -67,30 +51,22 @@ SYMBOL TABLE SSA
(struct Point) Vector::p
(struct Point) Vector::q
(void()) main()
(byte*~) main::$0
(byte*~) main::$1
(byte*~) main::$2
(byte*~) main::$3
(byte*~) main::$4
(byte*~) main::$5
(byte*~) main::$6
(byte*~) main::$7
(label) main::@return
(struct Vector) main::v loadstore
Adding number conversion cast (unumber) 2 in *((byte*~) main::$0) ← (number) 2
Adding number conversion cast (unumber) 3 in *((byte*~) main::$1) ← (number) 3
Adding number conversion cast (unumber) 4 in *((byte*~) main::$2) ← (number) 4
Adding number conversion cast (unumber) 5 in *((byte*~) main::$3) ← (number) 5
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$6)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$7)
Adding number conversion cast (unumber) 2 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 2
Adding number conversion cast (unumber) 3 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 3
Adding number conversion cast (unumber) 4 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (number) 4
Adding number conversion cast (unumber) 5 in *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y) ← (number) 5
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast *((byte*~) main::$0) ← (unumber)(number) 2
Inlining cast *((byte*~) main::$1) ← (unumber)(number) 3
Inlining cast *((byte*~) main::$2) ← (unumber)(number) 4
Inlining cast *((byte*~) main::$3) ← (unumber)(number) 5
Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (unumber)(number) 2
Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (unumber)(number) 3
Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (unumber)(number) 4
Inlining cast *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y) ← (unumber)(number) 5
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 2
@ -112,46 +88,19 @@ Finalized unsigned number type (byte) 2
Finalized unsigned number type (byte) 3
Successful SSA optimization PassNFinalizeNumberTypeConversions
Removing C-classic struct-unwound assignment [1] (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
Constant right-side identified [2] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [4] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [6] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [8] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [10] (byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [12] (byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [14] (byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [16] (byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$4 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$5 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$6 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$7 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero SCREEN in [11] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$4)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [2] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
Simplifying expression containing zero (struct Point*)&main::v in [2] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← (byte) 2
Simplifying expression containing zero (struct Point*)&main::v in [3] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (byte) 3
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [4] *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 4
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [6] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v in [6] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero SCREEN in [6] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
Simplifying expression containing zero (struct Point*)&main::v in [7] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [8] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
Constant inlined main::$5 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$6 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$4 = (byte*)(struct Point*)&(struct Vector) main::v
Constant inlined main::$7 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+1)
Consolidated array index constant in *(SCREEN+2)
Consolidated array index constant in *(SCREEN+3)
@ -223,8 +172,8 @@ Target platform is c64basic / MOS6502X
// Global Constants & labels
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
@ -314,8 +263,8 @@ ASSEMBLER BEFORE OPTIMIZATION
// Global Constants & labels
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
@ -422,8 +371,8 @@ Score: 73
// Global Constants & labels
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
// @begin
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1

2
src/test/ref/struct-18.asm
View File

@ -4,8 +4,8 @@
.pc = $80d "Program"
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
main: {
.label v = 2
ldy #SIZEOF_STRUCT_VECTOR

67
src/test/ref/struct-18.log
View File

@ -1,12 +1,8 @@
Adding value bulk copy *(&(struct Vector) main::v) ← memcpy(*(&(const struct Vector) $0), struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -16,14 +12,10 @@ CONTROL FLOW GRAPH SSA
main: scope:[main] from @1
*(&(struct Vector) main::v) ← memcpy(*(&(const struct Vector) $0), struct Vector, (const byte) SIZEOF_STRUCT_VECTOR)
(struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
(byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
(byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
(byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
(byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
*((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
*((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
to:main::@return
main::@return: scope:[main] from main
return
@ -52,17 +44,13 @@ SYMBOL TABLE SSA
(struct Point) Vector::p
(struct Point) Vector::q
(void()) main()
(byte*~) main::$0
(byte*~) main::$1
(byte*~) main::$2
(byte*~) main::$3
(label) main::@return
(struct Vector) main::v loadstore
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -76,30 +64,15 @@ Finalized unsigned number type (byte) 2
Finalized unsigned number type (byte) 3
Successful SSA optimization PassNFinalizeNumberTypeConversions
Removing C-classic struct-unwound assignment [1] (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
Constant right-side identified [2] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [4] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [6] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [8] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero SCREEN in [3] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$0)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [2] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v in [2] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero SCREEN in [2] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
Simplifying expression containing zero (struct Point*)&main::v in [3] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [4] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+1)
Consolidated array index constant in *(SCREEN+2)
Consolidated array index constant in *(SCREEN+3)
@ -167,8 +140,8 @@ Target platform is c64basic / MOS6502X
// Global Constants & labels
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
@ -243,8 +216,8 @@ ASSEMBLER BEFORE OPTIMIZATION
// Global Constants & labels
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
// @begin
__bbegin:
// [1] phi from @begin to @1 [phi:@begin->@1]
@ -341,8 +314,8 @@ Score: 53
// Global Constants & labels
.label SCREEN = $400
.const SIZEOF_STRUCT_VECTOR = 4
.const OFFSET_STRUCT_VECTOR_Q = 2
.const OFFSET_STRUCT_POINT_Y = 1
.const OFFSET_STRUCT_VECTOR_Q = 2
// @begin
// [1] phi from @begin to @1 [phi:@begin->@1]
// @1

61
src/test/ref/struct-19.log
View File

@ -3,14 +3,10 @@ Adding value bulk copy *(&(struct Point) main::p1) ← memcpy(*(&(const struct P
Adding value bulk copy *(&(struct Point) main::p2) ← memcpy(*(&(const struct Point) $1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -26,14 +22,10 @@ main: scope:[main] from @1
(struct Point) main::p2 ← struct-unwound {*(&(struct Point) main::p2)}
*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
(byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
(byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
(byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
(byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
*((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
*((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
to:main::@return
main::@return: scope:[main] from main
return
@ -64,19 +56,15 @@ SYMBOL TABLE SSA
(struct Point) Vector::p
(struct Point) Vector::q
(void()) main()
(byte*~) main::$0
(byte*~) main::$1
(byte*~) main::$2
(byte*~) main::$3
(label) main::@return
(struct Point) main::p1 loadstore
(struct Point) main::p2 loadstore
(struct Vector) main::v loadstore
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -92,31 +80,16 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
Removing C-classic struct-unwound assignment [1] (struct Vector) main::v ← struct-unwound {*(&(struct Vector) main::v)}
Removing C-classic struct-unwound assignment [3] (struct Point) main::p1 ← struct-unwound {*(&(struct Point) main::p1)}
Removing C-classic struct-unwound assignment [5] (struct Point) main::p2 ← struct-unwound {*(&(struct Point) main::p2)}
Constant right-side identified [8] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [10] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [12] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [14] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero (struct Point*)&main::v in [6] *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Simplifying expression containing zero SCREEN in [9] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$0)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
Simplifying expression containing zero (struct Point*)&main::v in [9] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [10] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+1)
Consolidated array index constant in *(SCREEN+2)
Consolidated array index constant in *(SCREEN+3)

61
src/test/ref/struct-20.log
View File

@ -3,14 +3,10 @@ Adding value bulk copy *(&(struct Point) main::p2) ← memcpy(*(&(const struct P
Unwinding value copy (struct Vector) main::v ← (struct Vector){ (struct Point) main::p1, (struct Point) main::p2 }
Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Adding value bulk copy *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.p with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v.q with member unwinding reference *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Replacing struct member reference (struct Vector) main::v.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -25,14 +21,10 @@ main: scope:[main] from @1
*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q) ← memcpy(*(&(struct Point) main::p2), struct Point, (const byte) SIZEOF_STRUCT_POINT)
(struct Vector) main::v ← struct-unwound {*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P), *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)}
(byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
(byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
(byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
(byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
*((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
*((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
*((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
to:main::@return
main::@return: scope:[main] from main
return
@ -62,19 +54,15 @@ SYMBOL TABLE SSA
(struct Point) Vector::p
(struct Point) Vector::q
(void()) main()
(byte*~) main::$0
(byte*~) main::$1
(byte*~) main::$2
(byte*~) main::$3
(label) main::@return
(struct Point) main::p1 loadstore
(struct Point) main::p2 loadstore
(struct Vector) main::v loadstore
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$0)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$1)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*~) main::$2)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*~) main::$3)
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Adding number conversion cast (unumber) 2 in *((const byte*) SCREEN + (number) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Adding number conversion cast (unumber) 3 in *((const byte*) SCREEN + (number) 3) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -90,31 +78,16 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
Removing C-classic struct-unwound assignment [1] (struct Point) main::p1 ← struct-unwound {*(&(struct Point) main::p1)}
Removing C-classic struct-unwound assignment [3] (struct Point) main::p2 ← struct-unwound {*(&(struct Point) main::p2)}
Removing C-classic struct-unwound assignment [6] (struct Vector) main::v ← struct-unwound {*((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P), *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q)}
Constant right-side identified [7] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [9] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [11] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [13] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (struct Point*)&main::v in
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero (struct Point*)&main::v in [4] *((struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P) ← memcpy(*(&(struct Point) main::p1), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$0)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_P in [7] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v in [7] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero SCREEN in [7] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(struct Point*)&(struct Vector) main::v)
Simplifying expression containing zero (struct Point*)&main::v in [8] *((const byte*) SCREEN + (byte) 1) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v+OFFSET_STRUCT_VECTOR_Q in [9] *((const byte*) SCREEN + (byte) 2) ← *((byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+1)
Consolidated array index constant in *(SCREEN+2)
Consolidated array index constant in *(SCREEN+3)

4
src/test/ref/struct-21.log
View File

@ -1,7 +1,7 @@
Setting inferred volatile on symbol affected by address-of (struct Point*) main::ptr ← &(struct Point) main::point1
Adding value bulk copy *(&(struct Point) main::point1) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Rewriting struct pointer member access *((struct Point*) main::ptr).x
Rewriting struct pointer member access *((struct Point*) main::ptr).y
Replacing struct member reference *((struct Point*) main::ptr).x with member unwinding reference *((byte*~) main::$0)
Replacing struct member reference *((struct Point*) main::ptr).y with member unwinding reference *((byte*~) main::$1)
Identified constant variable (struct Point*) main::ptr
CONTROL FLOW GRAPH SSA

48
src/test/ref/struct-40.log
View File

@ -62,38 +62,22 @@ Adding value simple copy (byte) main::v4_p_y ← (byte) main::v1_p_y
Unwinding value copy (struct Vector) main::v4 ← (struct Vector){ (struct Point){ (struct Vector) main::v1.p.x, (struct Vector) main::v1.p.y }, { x: (byte) 8, y: (byte) 9 } }
Adding value simple copy (byte) main::v4_q_x ← (byte) 8
Adding value simple copy (byte) main::v4_q_y ← (byte) 9
Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference (struct Point) main::v2_p
Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference (struct Point) main::v2_p
Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference (struct Point) main::v2_q
Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference (struct Point) main::v2_q
Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference (struct Point) main::v3_p
Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference (struct Point) main::v3_p
Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference (struct Point) main::v3_q
Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference (struct Point) main::v3_q
Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference (struct Point) main::v4_p
Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference (struct Point) main::v4_p
Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference (struct Point) main::v4_q
Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference (struct Point) main::v4_q
Replacing struct member reference (struct Point) main::v1_p.x with member unwinding reference (byte) main::v1_p_x
Replacing struct member reference (struct Point) main::v1_p.y with member unwinding reference (byte) main::v1_p_y
Replacing struct member reference (struct Point) main::v1_q.x with member unwinding reference (byte) main::v1_q_x
Replacing struct member reference (struct Point) main::v1_q.y with member unwinding reference (byte) main::v1_q_y
Replacing struct member reference (struct Point) main::v2_p.x with member unwinding reference (byte) main::v2_p_x
Replacing struct member reference (struct Point) main::v2_p.y with member unwinding reference (byte) main::v2_p_y
Replacing struct member reference (struct Point) main::v2_q.x with member unwinding reference (byte) main::v2_q_x
Replacing struct member reference (struct Point) main::v2_q.y with member unwinding reference (byte) main::v2_q_y
Replacing struct member reference (struct Point) main::v3_p.x with member unwinding reference (byte) main::v3_p_x
Replacing struct member reference (struct Point) main::v3_p.y with member unwinding reference (byte) main::v3_p_y
Replacing struct member reference (struct Point) main::v3_q.x with member unwinding reference (byte) main::v3_q_x
Replacing struct member reference (struct Point) main::v3_q.y with member unwinding reference (byte) main::v3_q_y
Replacing struct member reference (struct Point) main::v4_p.x with member unwinding reference (byte) main::v4_p_x
Replacing struct member reference (struct Point) main::v4_p.y with member unwinding reference (byte) main::v4_p_y
Replacing struct member reference (struct Point) main::v4_q.x with member unwinding reference (byte) main::v4_q_x
Replacing struct member reference (struct Point) main::v4_q.y with member unwinding reference (byte) main::v4_q_y
Replacing struct member reference (struct Vector) main::v1.p.x with member unwinding reference (byte) main::v1_p_x
Replacing struct member reference (struct Vector) main::v1.p.y with member unwinding reference (byte) main::v1_p_y
Replacing struct member reference (struct Vector) main::v1.q.x with member unwinding reference (byte) main::v1_q_x
Replacing struct member reference (struct Vector) main::v1.q.y with member unwinding reference (byte) main::v1_q_y
Replacing struct member reference (struct Vector) main::v2.p.x with member unwinding reference (byte) main::v2_p_x
Replacing struct member reference (struct Vector) main::v2.p.y with member unwinding reference (byte) main::v2_p_y
Replacing struct member reference (struct Vector) main::v2.q.x with member unwinding reference (byte) main::v2_q_x
Replacing struct member reference (struct Vector) main::v2.q.y with member unwinding reference (byte) main::v2_q_y
Replacing struct member reference (struct Vector) main::v3.p.x with member unwinding reference (byte) main::v3_p_x
Replacing struct member reference (struct Vector) main::v3.p.y with member unwinding reference (byte) main::v3_p_y
Replacing struct member reference (struct Vector) main::v3.q.x with member unwinding reference (byte) main::v3_q_x
Replacing struct member reference (struct Vector) main::v3.q.y with member unwinding reference (byte) main::v3_q_y
Replacing struct member reference (struct Vector) main::v4.p.x with member unwinding reference (byte) main::v4_p_x
Replacing struct member reference (struct Vector) main::v4.p.y with member unwinding reference (byte) main::v4_p_y
Replacing struct member reference (struct Vector) main::v4.q.x with member unwinding reference (byte) main::v4_q_x
Replacing struct member reference (struct Vector) main::v4.q.y with member unwinding reference (byte) main::v4_q_y
Identified constant variable (byte) main::v1_p_x
Identified constant variable (byte) main::v1_p_y
Identified constant variable (byte) main::v1_q_x

169
src/test/ref/struct-41.log
View File

@ -41,46 +41,26 @@ Adding value simple copy (byte) main::v5_p_y ← *((byte*)(struct Point*)&(struc
Unwinding value copy (struct Vector) main::v5 ← (struct Vector){ (struct Point){ (struct Vector) main::v4.p.x, (struct Vector) main::v4.p.y }, { x: (byte) 8, y: (byte) 9 } }
Adding value simple copy (byte) main::v5_q_x ← (byte) 8
Adding value simple copy (byte) main::v5_q_y ← (byte) 9
Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
Replacing struct member reference (struct Vector) main::v1.p with member unwinding reference (struct Point) main::v1_p
Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
Replacing struct member reference (struct Vector) main::v1.q with member unwinding reference (struct Point) main::v1_q
Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v2.p with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v2.q with member unwinding reference *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v3.p with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v3.q with member unwinding reference *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v4.p with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v4.q with member unwinding reference *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q)
Replacing struct member reference (struct Vector) main::v5.p with member unwinding reference (struct Point) main::v5_p
Replacing struct member reference (struct Vector) main::v5.p with member unwinding reference (struct Point) main::v5_p
Replacing struct member reference (struct Vector) main::v5.q with member unwinding reference (struct Point) main::v5_q
Replacing struct member reference (struct Vector) main::v5.q with member unwinding reference (struct Point) main::v5_q
Replacing struct member reference (struct Point) main::v1_p.x with member unwinding reference (byte) main::v1_p_x
Replacing struct member reference (struct Point) main::v1_p.y with member unwinding reference (byte) main::v1_p_y
Replacing struct member reference (struct Point) main::v1_q.x with member unwinding reference (byte) main::v1_q_x
Replacing struct member reference (struct Point) main::v1_q.y with member unwinding reference (byte) main::v1_q_y
Replacing struct member reference (struct Point) main::v5_p.x with member unwinding reference (byte) main::v5_p_x
Replacing struct member reference (struct Point) main::v5_p.y with member unwinding reference (byte) main::v5_p_y
Replacing struct member reference (struct Point) main::v5_q.x with member unwinding reference (byte) main::v5_q_x
Replacing struct member reference (struct Point) main::v5_q.y with member unwinding reference (byte) main::v5_q_y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P).y
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q).x
Rewriting struct pointer member access *((struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q).y
Replacing struct member reference (struct Vector) main::v1.p.x with member unwinding reference (byte) main::v1_p_x
Replacing struct member reference (struct Vector) main::v1.p.y with member unwinding reference (byte) main::v1_p_y
Replacing struct member reference (struct Vector) main::v1.q.x with member unwinding reference (byte) main::v1_q_x
Replacing struct member reference (struct Vector) main::v1.q.y with member unwinding reference (byte) main::v1_q_y
Replacing struct member reference (struct Vector) main::v2.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v2.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v2.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v2.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v3.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v3.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v3.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v3.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v4.p.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v4.p.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v4.q.x with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Replacing struct member reference (struct Vector) main::v4.q.y with member unwinding reference *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
Replacing struct member reference (struct Vector) main::v5.p.x with member unwinding reference (byte) main::v5_p_x
Replacing struct member reference (struct Vector) main::v5.p.y with member unwinding reference (byte) main::v5_p_y
Replacing struct member reference (struct Vector) main::v5.q.x with member unwinding reference (byte) main::v5_q_x
Replacing struct member reference (struct Vector) main::v5.q.y with member unwinding reference (byte) main::v5_q_y
Identified constant variable (byte) main::v1_p_x
Identified constant variable (byte) main::v1_p_y
Identified constant variable (byte) main::v1_q_x
@ -115,41 +95,29 @@ main: scope:[main] from @1
(byte) main::idx#3 ← ++ (byte) main::idx#2
*((const byte*) SCREEN + (byte) main::idx#3) ← (const byte) main::v1_q_y
(byte) main::idx#4 ← ++ (byte) main::idx#3
(byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*~) main::$0)
*((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
(byte) main::idx#5 ← ++ (byte) main::idx#4
(byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (byte) main::idx#5) ← *((byte*~) main::$1)
*((const byte*) SCREEN + (byte) main::idx#5) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
(byte) main::idx#6 ← ++ (byte) main::idx#5
(byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (byte) main::idx#6) ← *((byte*~) main::$2)
*((const byte*) SCREEN + (byte) main::idx#6) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
(byte) main::idx#7 ← ++ (byte) main::idx#6
(byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (byte) main::idx#7) ← *((byte*~) main::$3)
*((const byte*) SCREEN + (byte) main::idx#7) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
(byte) main::idx#8 ← ++ (byte) main::idx#7
(byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*~) main::$4)
*((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
(byte) main::idx#9 ← ++ (byte) main::idx#8
(byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (byte) main::idx#9) ← *((byte*~) main::$5)
*((const byte*) SCREEN + (byte) main::idx#9) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
(byte) main::idx#10 ← ++ (byte) main::idx#9
(byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (byte) main::idx#10) ← *((byte*~) main::$6)
*((const byte*) SCREEN + (byte) main::idx#10) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
(byte) main::idx#11 ← ++ (byte) main::idx#10
(byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (byte) main::idx#11) ← *((byte*~) main::$7)
*((const byte*) SCREEN + (byte) main::idx#11) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
(byte) main::idx#12 ← ++ (byte) main::idx#11
(byte*~) main::$8 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*~) main::$8)
*((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
(byte) main::idx#13 ← ++ (byte) main::idx#12
(byte*~) main::$9 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (byte) main::idx#13) ← *((byte*~) main::$9)
*((const byte*) SCREEN + (byte) main::idx#13) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
(byte) main::idx#14 ← ++ (byte) main::idx#13
(byte*~) main::$10 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (byte) main::idx#14) ← *((byte*~) main::$10)
*((const byte*) SCREEN + (byte) main::idx#14) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
(byte) main::idx#15 ← ++ (byte) main::idx#14
(byte*~) main::$11 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (byte) main::idx#15) ← *((byte*~) main::$11)
*((const byte*) SCREEN + (byte) main::idx#15) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)
(byte) main::idx#16 ← ++ (byte) main::idx#15
*((const byte*) SCREEN + (byte) main::idx#16) ← (byte) main::v5_p_x#0
(byte) main::idx#17 ← ++ (byte) main::idx#16
@ -188,18 +156,6 @@ SYMBOL TABLE SSA
(struct Point) Vector::p
(struct Point) Vector::q
(void()) main()
(byte*~) main::$0
(byte*~) main::$1
(byte*~) main::$10
(byte*~) main::$11
(byte*~) main::$2
(byte*~) main::$3
(byte*~) main::$4
(byte*~) main::$5
(byte*~) main::$6
(byte*~) main::$7
(byte*~) main::$8
(byte*~) main::$9
(label) main::@return
(byte) main::idx
(byte) main::idx#0
@ -246,45 +202,8 @@ Successful SSA optimization PassNCastSimplification
Removing C-classic struct-unwound assignment [5] (struct Vector) main::v2 ← struct-unwound {*((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X), *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y), *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X), *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y)}
Removing C-classic struct-unwound assignment [8] (struct Vector) main::v3 ← struct-unwound {*((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P), *((struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q)}
Removing C-classic struct-unwound assignment [10] (struct Vector) main::v4 ← struct-unwound {*(&(struct Vector) main::v4)}
Constant right-side identified [21] (byte*~) main::$0 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [24] (byte*~) main::$1 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [27] (byte*~) main::$2 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [30] (byte*~) main::$3 ← (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [33] (byte*~) main::$4 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [36] (byte*~) main::$5 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [39] (byte*~) main::$6 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [42] (byte*~) main::$7 ← (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [45] (byte*~) main::$8 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [48] (byte*~) main::$9 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [51] (byte*~) main::$10 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [54] (byte*~) main::$11 ← (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::idx#0 = 0
Constant (const byte*) main::$0 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$1 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$2 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$3 = (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$4 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$5 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$6 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$7 = (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$8 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$9 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$10 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$11 = (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v2 in
Simplifying expression containing zero (struct Point*)&main::v2 in
Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v3 in
Simplifying expression containing zero (struct Point*)&main::v3 in
Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P in
Simplifying expression containing zero (struct Point*)&main::v4 in
Simplifying expression containing zero (struct Point*)&main::v4 in
Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q in
Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P in [1] *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X) ← (const byte) main::v1_p_x
Simplifying expression containing zero (struct Point*)&main::v2 in [1] *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P) ← (const byte) main::v1_p_x
Simplifying expression containing zero (struct Point*)&main::v2 in [2] *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y) ← (const byte) main::v1_p_y
@ -295,6 +214,18 @@ Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_ST
Simplifying expression containing zero (struct Point*)&main::v4 in [11] (byte) main::v5_p_x#0 ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero (struct Point*)&main::v4 in [12] (byte) main::v5_p_y#0 ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero SCREEN in [13] *((const byte*) SCREEN + (const byte) main::idx#0) ← (const byte) main::v1_p_x
Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_P in [21] *((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v2 in [21] *((const byte*) SCREEN + (byte) main::idx#4) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero (struct Point*)&main::v2 in [23] *((const byte*) SCREEN + (byte) main::idx#5) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v2+OFFSET_STRUCT_VECTOR_Q in [25] *((const byte*) SCREEN + (byte) main::idx#6) ← *((byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_P in [29] *((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v3 in [29] *((const byte*) SCREEN + (byte) main::idx#8) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero (struct Point*)&main::v3 in [31] *((const byte*) SCREEN + (byte) main::idx#9) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v3+OFFSET_STRUCT_VECTOR_Q in [33] *((const byte*) SCREEN + (byte) main::idx#10) ← *((byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_P in [37] *((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (struct Point*)&main::v4 in [37] *((const byte*) SCREEN + (byte) main::idx#12) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P)
Simplifying expression containing zero (struct Point*)&main::v4 in [39] *((const byte*) SCREEN + (byte) main::idx#13) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_P+(const byte) OFFSET_STRUCT_POINT_Y)
Simplifying expression containing zero (byte*)(struct Point*)&main::v4+OFFSET_STRUCT_VECTOR_Q in [41] *((const byte*) SCREEN + (byte) main::idx#14) ← *((byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_X)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (byte) main::idx#20 and assignment [48] (byte) main::idx#20 ← ++ (byte) main::idx#19
Eliminating unused constant (const byte) OFFSET_STRUCT_VECTOR_P
@ -404,30 +335,18 @@ Constant inlined main::idx#12 = ++++++++++++++++++++++++(byte) 0
Constant inlined main::idx#13 = ++++++++++++++++++++++++++(byte) 0
Constant inlined main::idx#14 = ++++++++++++++++++++++++++++(byte) 0
Constant inlined main::idx#15 = ++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$10 = (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::$11 = (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::idx#0 = (byte) 0
Constant inlined main::idx#1 = ++(byte) 0
Constant inlined main::idx#2 = ++++(byte) 0
Constant inlined main::$1 = (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::idx#3 = ++++++(byte) 0
Constant inlined main::$2 = (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::idx#4 = ++++++++(byte) 0
Constant inlined main::idx#5 = ++++++++++(byte) 0
Constant inlined main::$0 = (byte*)(struct Point*)&(struct Vector) main::v2
Constant inlined main::idx#6 = ++++++++++++(byte) 0
Constant inlined main::$5 = (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::idx#7 = ++++++++++++++(byte) 0
Constant inlined main::$6 = (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q
Constant inlined main::idx#8 = ++++++++++++++++(byte) 0
Constant inlined main::$3 = (byte*)(struct Point*)&(struct Vector) main::v2+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::idx#9 = ++++++++++++++++++(byte) 0
Constant inlined main::idx#10 = ++++++++++++++++++++(byte) 0
Constant inlined main::$4 = (byte*)(struct Point*)&(struct Vector) main::v3
Constant inlined main::idx#11 = ++++++++++++++++++++++(byte) 0
Constant inlined main::$9 = (byte*)(struct Point*)&(struct Vector) main::v4+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$7 = (byte*)(struct Point*)&(struct Vector) main::v3+(const byte) OFFSET_STRUCT_VECTOR_Q+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$8 = (byte*)(struct Point*)&(struct Vector) main::v4
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(SCREEN+++0)
Consolidated array index constant in *(SCREEN+++++0)

30
src/test/ref/struct-42.log
View File

@ -3,8 +3,8 @@ Fixing pointer array-indexing *((const struct Point*) points + (number) 2)
Fixing pointer array-indexing *((const struct Point*) points + (number) 2)
Constantified RValue *((const struct Point*) points + (byte~) main::$1) ← { x: (byte) 2, y: (byte) 3 }
Adding value bulk copy *((const struct Point*) points + (byte~) main::$1) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$2).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$3).y
Replacing struct member reference *((const struct Point*) points + (number~) main::$2).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
Replacing struct member reference *((const struct Point*) points + (number~) main::$3).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -24,11 +24,9 @@ main::@1: scope:[main] from main main::@1
to:main::@2
main::@2: scope:[main] from main::@1
(number~) main::$2 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4 + (number~) main::$2)
*((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
(number~) main::$3 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5 + (number~) main::$3)
*((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
to:main::@return
main::@return: scope:[main] from main::@2
return
@ -57,8 +55,6 @@ SYMBOL TABLE SSA
(byte~) main::$1
(number~) main::$2
(number~) main::$3
(byte*~) main::$4
(byte*~) main::$5
(label) main::@1
(label) main::@2
(label) main::@return
@ -70,10 +66,10 @@ SYMBOL TABLE SSA
Adding number conversion cast (unumber) 2 in (number~) main::$2 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 2 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*~) main::$4 + (unumber~) main::$2)
Adding number conversion cast (unumber) 0 in *((const byte*) SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2)
Adding number conversion cast (unumber) 2 in (number~) main::$3 ← (number) 2 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 2 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*~) main::$5 + (unumber~) main::$3)
Adding number conversion cast (unumber) 1 in *((const byte*) SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3)
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 2
@ -91,20 +87,16 @@ Inferred type updated to byte in (unumber~) main::$3 ← (byte) 2 * (const byte)
Simple Condition (bool~) main::$0 [6] if((byte) main::i#1!=rangelast(0,2)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [7] (byte~) main::$2 ← (byte) 2 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [8] (byte*~) main::$4 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [10] (byte~) main::$3 ← (byte) 2 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [11] (byte*~) main::$5 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [9] (byte~) main::$3 ← (byte) 2 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::i#0 = 0
Constant (const byte) main::$2 = 2*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$4 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$3 = 2*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$5 = (byte*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [4] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [6] if(main::i#1!=rangelast(0,2)) goto main::@1 to (number) 3
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero SCREEN in [9] *((const byte*) SCREEN + (byte) 0) ← *((const byte*) main::$4 + (const byte) main::$2)
Simplifying expression containing zero (byte*)points in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$2)
Simplifying expression containing zero SCREEN in [8] *((const byte*) SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points + (const byte) main::$2)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
@ -117,11 +109,9 @@ Successful SSA optimization PassNFinalizeNumberTypeConversions
Rewriting multiplication to use shift [1] (byte~) main::$1 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2MultiplyToShiftRewriting
Inlining constant with var siblings (const byte) main::i#0
Constant inlined main::$5 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::i#0 = (byte) 0
Constant inlined main::$3 = (byte) 2*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$4 = (byte*)(const struct Point*) points
Constant inlined main::$2 = (byte) 2*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$3 = (byte) 2*(const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *((byte*)points+2*SIZEOF_STRUCT_POINT)
Consolidated array index constant in *((byte*)points+OFFSET_STRUCT_POINT_Y+2*SIZEOF_STRUCT_POINT)

6
src/test/ref/struct-6.log
View File

@ -15,11 +15,9 @@ Unwinding value copy (struct Circle) main::c ← (struct Circle){ (struct Point)
Adding value simple copy (byte) main::c_center_x ← (byte) main::p_x
Adding value simple copy (byte) main::c_center_y ← (byte) main::p_y
Adding value simple copy (byte) main::c_radius ← (byte) 5
Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
Replacing struct member reference (struct Circle) main::c.center.x with member unwinding reference (byte) main::c_center_x
Replacing struct member reference (struct Circle) main::c.center.y with member unwinding reference (byte) main::c_center_y
Replacing struct member reference (struct Circle) main::c.radius with member unwinding reference (byte) main::c_radius
Replacing struct member reference (struct Point) main::c_center.x with member unwinding reference (byte) main::c_center_x
Replacing struct member reference (struct Point) main::c_center.y with member unwinding reference (byte) main::c_center_y
Identified constant variable (byte) main::p_x
Identified constant variable (byte) main::p_y
Identified constant variable (byte) main::c_radius

22
src/test/ref/struct-7.log
View File

@ -24,22 +24,12 @@ Unwinding value copy (struct TwoCircles) main::t ← { c1: { center: { x: (byte)
Adding value simple copy (byte) main::t_c2_center_x ← (byte) 4
Adding value simple copy (byte) main::t_c2_center_y ← (byte) 5
Adding value simple copy (byte) main::t_c2_radius ← (byte) 6
Replacing struct member reference (struct TwoCircles) main::t.c1 with member unwinding reference (struct Circle) main::t_c1
Replacing struct member reference (struct TwoCircles) main::t.c1 with member unwinding reference (struct Circle) main::t_c1
Replacing struct member reference (struct TwoCircles) main::t.c1 with member unwinding reference (struct Circle) main::t_c1
Replacing struct member reference (struct TwoCircles) main::t.c2 with member unwinding reference (struct Circle) main::t_c2
Replacing struct member reference (struct TwoCircles) main::t.c2 with member unwinding reference (struct Circle) main::t_c2
Replacing struct member reference (struct TwoCircles) main::t.c2 with member unwinding reference (struct Circle) main::t_c2
Replacing struct member reference (struct Circle) main::t_c1.center with member unwinding reference (struct Point) main::t_c1_center
Replacing struct member reference (struct Circle) main::t_c1.center with member unwinding reference (struct Point) main::t_c1_center
Replacing struct member reference (struct Circle) main::t_c1.radius with member unwinding reference (byte) main::t_c1_radius
Replacing struct member reference (struct Circle) main::t_c2.center with member unwinding reference (struct Point) main::t_c2_center
Replacing struct member reference (struct Circle) main::t_c2.center with member unwinding reference (struct Point) main::t_c2_center
Replacing struct member reference (struct Circle) main::t_c2.radius with member unwinding reference (byte) main::t_c2_radius
Replacing struct member reference (struct Point) main::t_c1_center.x with member unwinding reference (byte) main::t_c1_center_x
Replacing struct member reference (struct Point) main::t_c1_center.y with member unwinding reference (byte) main::t_c1_center_y
Replacing struct member reference (struct Point) main::t_c2_center.x with member unwinding reference (byte) main::t_c2_center_x
Replacing struct member reference (struct Point) main::t_c2_center.y with member unwinding reference (byte) main::t_c2_center_y
Replacing struct member reference (struct TwoCircles) main::t.c1.center.x with member unwinding reference (byte) main::t_c1_center_x
Replacing struct member reference (struct TwoCircles) main::t.c1.center.y with member unwinding reference (byte) main::t_c1_center_y
Replacing struct member reference (struct TwoCircles) main::t.c1.radius with member unwinding reference (byte) main::t_c1_radius
Replacing struct member reference (struct TwoCircles) main::t.c2.center.x with member unwinding reference (byte) main::t_c2_center_x
Replacing struct member reference (struct TwoCircles) main::t.c2.center.y with member unwinding reference (byte) main::t_c2_center_y
Replacing struct member reference (struct TwoCircles) main::t.c2.radius with member unwinding reference (byte) main::t_c2_radius
Identified constant variable (byte) main::t_c1_radius
Identified constant variable (byte) main::t_c2_radius
Identified constant variable (byte) main::t_c1_center_x

6
src/test/ref/struct-9.log
View File

@ -19,11 +19,9 @@ Unwinding value copy (struct Circle) main::c.center ← (struct Point) main::p
Adding value simple copy (byte) main::c_center_x ← (byte) main::p_x
Adding value simple copy (byte) main::c_center_y ← (byte) main::p_y
Replacing struct member reference (struct Circle) main::c.radius with member unwinding reference (byte) main::c_radius
Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
Replacing struct member reference (struct Circle) main::c.center with member unwinding reference (struct Point) main::c_center
Replacing struct member reference (struct Circle) main::c.center.x with member unwinding reference (byte) main::c_center_x
Replacing struct member reference (struct Circle) main::c.center.y with member unwinding reference (byte) main::c_center_y
Replacing struct member reference (struct Circle) main::c.radius with member unwinding reference (byte) main::c_radius
Replacing struct member reference (struct Point) main::c_center.x with member unwinding reference (byte) main::c_center_x
Replacing struct member reference (struct Point) main::c_center.y with member unwinding reference (byte) main::c_center_y
Identified constant variable (byte) main::p_x
Identified constant variable (byte) main::p_y

25
src/test/ref/struct-pos-fill.log
View File

@ -1,7 +1,7 @@
Fixing pointer array-indexing *((const struct pos*) p + (byte) idx)
Fixing pointer array-indexing *((const struct pos*) p + (byte) idx)
Rewriting struct pointer member access *((const struct pos*) p + (byte~) main::$2).y
Rewriting struct pointer member access *((const struct pos*) p + (byte~) main::$3).x
Replacing struct member reference *((const struct pos*) p + (byte~) main::$2).y with member unwinding reference *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_Y + (byte~) main::$2)
Replacing struct member reference *((const struct pos*) p + (byte~) main::$3).x with member unwinding reference *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_X + (byte~) main::$3)
Identified constant variable (byte) OFFSET
Identified constant variable (byte) XSPACE
Identified constant variable (byte) YSPACE
@ -63,11 +63,9 @@ main::@5: scope:[main] from main::@4
(byte) y#4 ← phi( main::@4/(byte) y#8 )
(byte) idx#4 ← phi( main::@4/(byte) idx#7 )
(byte~) main::$2 ← (byte) idx#4 * (const byte) SIZEOF_STRUCT_POS
(byte*~) main::$4 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_Y
*((byte*~) main::$4 + (byte~) main::$2) ← (byte) y#4
*((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_Y + (byte~) main::$2) ← (byte) y#4
(byte~) main::$3 ← (byte) idx#4 * (const byte) SIZEOF_STRUCT_POS
(byte*~) main::$5 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_X
*((byte*~) main::$5 + (byte~) main::$3) ← (byte) x#6
*((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_X + (byte~) main::$3) ← (byte) x#6
(byte) idx#1 ← ++ (byte) idx#4
(byte) x#2 ← (byte) x#6 + (const byte) XSPACE
(byte) row#2 ← ++ (byte) row#6
@ -159,8 +157,6 @@ SYMBOL TABLE SSA
(bool~) main::$1
(byte~) main::$2
(byte~) main::$3
(byte*~) main::$4
(byte*~) main::$5
(label) main::@1
(label) main::@2
(label) main::@4
@ -265,14 +261,11 @@ Identical Phi Values (byte) row#4 (byte) row#3
Identical Phi Values (byte) idx#3 (byte) idx#12
Identical Phi Values (byte) y#3 (byte) y#12
Successful SSA optimization Pass2IdenticalPhiElimination
Identified duplicate assignment right side [20] (byte~) main::$3 ← (byte) idx#11 * (const byte) SIZEOF_STRUCT_POS
Identified duplicate assignment right side [19] (byte~) main::$3 ← (byte) idx#11 * (const byte) SIZEOF_STRUCT_POS
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) main::$0 [9] if((byte) line#11<(byte) 8) goto main::@2
Simple Condition (bool~) main::$1 [15] if((byte) row#12<(byte) 8) goto main::@5
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [18] (byte*~) main::$4 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_Y
Constant right-side identified [21] (byte*~) main::$5 ← (byte*)(const struct pos*) p + (const byte) OFFSET_STRUCT_POS_X
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) idx#0 = 0
Constant (const byte) line#0 = 0
Constant (const byte) row#0 = 0
@ -280,10 +273,8 @@ Constant (const byte) x#0 = 0
Constant (const byte) y#0 = 0
Constant (const byte) line#1 = 0
Constant (const byte) row#1 = 0
Constant (const byte*) main::$4 = (byte*)p+OFFSET_STRUCT_POS_Y
Constant (const byte*) main::$5 = (byte*)p+OFFSET_STRUCT_POS_X
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero (byte*)p in
Simplifying expression containing zero (byte*)p in [20] *((byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_X + (byte~) main::$3) ← (byte) x#10
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable - keeping the phi block (byte) row#3
Eliminating unused constant (const byte) OFFSET_STRUCT_POS_X
@ -303,10 +294,8 @@ Inlining constant with var siblings (const byte) row#1
Constant inlined row#1 = (byte) 0
Constant inlined x#0 = (byte) 0
Constant inlined line#1 = (byte) 0
Constant inlined y#0 = (byte) 0
Constant inlined main::$5 = (byte*)(const struct pos*) p
Constant inlined main::$4 = (byte*)(const struct pos*) p+(const byte) OFFSET_STRUCT_POS_Y
Constant inlined idx#0 = (byte) 0
Constant inlined y#0 = (byte) 0
Successful SSA optimization Pass2ConstantInlining
Eliminating unused constant (const byte) SIZEOF_STRUCT_POS
Successful SSA optimization PassNEliminateUnusedVars

59
src/test/ref/struct-ptr-0.log
View File

@ -2,10 +2,10 @@ Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$3).x
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$4).y
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$5).x
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$6).y
Replacing struct member reference *((const struct Point*) points + (byte~) main::$3).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$4).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$5).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$5)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$6).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$6)
Culled Empty Block (label) main::@4
CONTROL FLOW GRAPH SSA
@ -19,12 +19,10 @@ main: scope:[main] from @1
main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte~) main::$3 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$7 + (byte~) main::$3) ← (byte) main::i#2
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3) ← (byte) main::i#2
(number~) main::$0 ← (byte) main::i#2 + (number) 1
(byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$8 + (byte~) main::$4) ← (number~) main::$0
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$4) ← (number~) main::$0
(byte) main::i#1 ← (byte) main::i#2 + rangenext(0,4)
(bool~) main::$1 ← (byte) main::i#1 != rangelast(0,4)
if((bool~) main::$1) goto main::@1
@ -35,11 +33,9 @@ main::@2: scope:[main] from main::@1
main::@3: scope:[main] from main::@2 main::@3
(byte) main::i1#2 ← phi( main::@2/(byte) main::i1#0 main::@3/(byte) main::i1#1 )
(byte~) main::$5 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) main::SCREEN + (byte) main::i1#2) ← *((byte*~) main::$9 + (byte~) main::$5)
*((const byte*) main::SCREEN + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$5)
(byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*~) main::$10 + (byte~) main::$6)
*((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$6)
(byte) main::i1#1 ← (byte) main::i1#2 + rangenext(0,4)
(bool~) main::$2 ← (byte) main::i1#1 != rangelast(0,4)
if((bool~) main::$2) goto main::@3
@ -67,15 +63,11 @@ SYMBOL TABLE SSA
(void()) main()
(number~) main::$0
(bool~) main::$1
(byte*~) main::$10
(bool~) main::$2
(byte~) main::$3
(byte~) main::$4
(byte~) main::$5
(byte~) main::$6
(byte*~) main::$7
(byte*~) main::$8
(byte*~) main::$9
(label) main::@1
(label) main::@2
(label) main::@3
@ -93,7 +85,7 @@ SYMBOL TABLE SSA
Adding number conversion cast (unumber) 1 in (number~) main::$0 ← (byte) main::i#2 + (number) 1
Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (byte) main::i#2 + (unumber)(number) 1
Adding number conversion cast (unumber) $28 in *((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*~) main::$10 + (byte~) main::$6)
Adding number conversion cast (unumber) $28 in *((const byte*) main::SCREEN+(number) $28 + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$6)
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 1
@ -103,30 +95,21 @@ Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) $28
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) main::$0 ← (byte) main::i#2 + (byte) 1
Identified duplicate assignment right side [6] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [17] (byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [5] (byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [14] (byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) main::$1 [11] if((byte) main::i#1!=rangelast(0,4)) goto main::@1
Simple Condition (bool~) main::$2 [22] if((byte) main::i1#1!=rangelast(0,4)) goto main::@3
Simple Condition (bool~) main::$1 [9] if((byte) main::i#1!=rangelast(0,4)) goto main::@1
Simple Condition (bool~) main::$2 [18] if((byte) main::i1#1!=rangelast(0,4)) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [3] (byte*~) main::$7 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [7] (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [15] (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [18] (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::i#0 = 0
Constant (const byte*) main::$7 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$8 = (byte*)points+OFFSET_STRUCT_POINT_Y
Constant (const byte) main::i1#0 = 0
Constant (const byte*) main::$9 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$10 = (byte*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [9] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [11] if(main::i#1!=rangelast(0,4)) goto main::@1 to (number) 5
Resolved ranged next value [20] main::i1#1 ← ++ main::i1#2 to ++
Resolved ranged comparison value [22] if(main::i1#1!=rangelast(0,4)) goto main::@3 to (number) 5
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero (byte*)points in
Resolved ranged next value [7] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [9] if(main::i#1!=rangelast(0,4)) goto main::@1 to (number) 5
Resolved ranged next value [16] main::i1#1 ← ++ main::i1#2 to ++
Resolved ranged comparison value [18] if(main::i1#1!=rangelast(0,4)) goto main::@3 to (number) 5
Simplifying expression containing zero (byte*)points in [3] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$3) ← (byte) main::i#2
Simplifying expression containing zero (byte*)points in [13] *((const byte*) main::SCREEN + (byte) main::i1#2) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$5)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
@ -149,10 +132,6 @@ Inlining constant with var siblings (const byte) main::i#0
Inlining constant with var siblings (const byte) main::i1#0
Constant inlined main::i#0 = (byte) 0
Constant inlined main::i1#0 = (byte) 0
Constant inlined main::$9 = (byte*)(const struct Point*) points
Constant inlined main::$7 = (byte*)(const struct Point*) points
Constant inlined main::$10 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$8 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantInlining
Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization PassNEliminateUnusedVars

4
src/test/ref/struct-ptr-12.log
View File

@ -1,7 +1,7 @@
Setting inferred volatile on symbol affected by address-of (struct Point*) main::q ← &(struct Point) main::p
Adding value bulk copy *(&(struct Point) main::p) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Rewriting struct pointer member access *((struct Point*) main::q).x
Rewriting struct pointer member access *((struct Point*) main::q).y
Replacing struct member reference *((struct Point*) main::q).x with member unwinding reference *((byte*~) main::$0)
Replacing struct member reference *((struct Point*) main::q).y with member unwinding reference *((byte*~) main::$1)
Identified constant variable (struct Point*) main::q
CONTROL FLOW GRAPH SSA

12
src/test/ref/struct-ptr-13.log
View File

@ -1,9 +1,9 @@
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).y
Rewriting struct pointer member access *((struct Point*) points).y
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).y
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$0)
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$1)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$2)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$3)
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$4)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$5)
Identified constant variable (struct Point*) points
CONTROL FLOW GRAPH SSA

8
src/test/ref/struct-ptr-14.log
View File

@ -1,9 +1,9 @@
Setting inferred volatile on symbol affected by address-of (struct Point*) main::q ← &(struct Point) main::p
Adding value bulk copy *(&(struct Point) main::p) ← memcpy(*(&(const struct Point) $0), struct Point, (const byte) SIZEOF_STRUCT_POINT)
Rewriting struct pointer member access *((struct Point*) main::q).x
Rewriting struct pointer member access *((struct Point*) main::q).y
Rewriting struct pointer member access *((struct Point*) set::ptr).x
Rewriting struct pointer member access *((struct Point*) set::ptr).y
Replacing struct member reference *((struct Point*) main::q).x with member unwinding reference *((byte*~) main::$1)
Replacing struct member reference *((struct Point*) main::q).y with member unwinding reference *((byte*~) main::$2)
Replacing struct member reference *((struct Point*) set::ptr).x with member unwinding reference *((byte*~) set::$0)
Replacing struct member reference *((struct Point*) set::ptr).y with member unwinding reference *((byte*~) set::$1)
Identified constant variable (struct Point*) main::q
Culled Empty Block (label) @1

8
src/test/ref/struct-ptr-15.asm
View File

@ -7,7 +7,7 @@
.const OFFSET_STRUCT_POINT_Y = 1
main: {
.label SCREEN = $400
.label __14 = 6
.label __9 = 6
.label x = 5
.label ptr = 2
.label i = 4
@ -37,12 +37,12 @@ main: {
tya
clc
adc.z ptr
sta.z __14
sta.z __9
lda #0
adc.z ptr+1
sta.z __14+1
sta.z __9+1
ldy #OFFSET_STRUCT_POINT_Y
lda (__14),y
lda (__9),y
tay
lda.z x
sta SCREEN,x

4
src/test/ref/struct-ptr-15.cfg
View File

@ -22,8 +22,8 @@ main::@1: scope:[main] from main main::@1
[10] (byte) main::idx#3 ← phi( main/(byte) 0 main::@1/(byte) main::idx#2 )
[10] (struct Circle*) main::ptr#2 ← phi( main/(const struct Circle*) circles main::@1/(struct Circle*) main::ptr#1 )
[11] (byte) main::x#0 ← *((byte*)(struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER)
[12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
[13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y)
[12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
[13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y)
[14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0
[15] (byte) main::idx#1 ← ++ (byte) main::idx#3
[16] *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0

251
src/test/ref/struct-ptr-15.log
View File

@ -5,20 +5,14 @@ Fixing pointer array-indexing *((const struct Circle*) circles + (number) 0)
Fixing pointer array-indexing *((const struct Circle*) circles + (number) 1)
Fixing pointer array-indexing *((const struct Circle*) circles + (number) 1)
Fixing pointer array-indexing *((const struct Circle*) circles + (number) 1)
Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$1).center
Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$2).center
Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$3).radius
Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$4).center
Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$5).center
Rewriting struct pointer member access *((const struct Circle*) circles + (number~) main::$6).radius
Rewriting struct pointer member access *((struct Circle*) main::ptr).center
Rewriting struct pointer member access *((struct Circle*) main::ptr).center
Rewriting struct pointer member access *((struct Point*~) main::$7 + (number~) main::$1).x
Rewriting struct pointer member access *((struct Point*~) main::$8 + (number~) main::$2).y
Rewriting struct pointer member access *((struct Point*~) main::$10 + (number~) main::$4).x
Rewriting struct pointer member access *((struct Point*~) main::$11 + (number~) main::$5).y
Rewriting struct pointer member access *((struct Point*~) main::$13).x
Rewriting struct pointer member access *((struct Point*~) main::$14).y
Replacing struct member reference *((const struct Circle*) circles + (number~) main::$1).center.x with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$1)
Replacing struct member reference *((const struct Circle*) circles + (number~) main::$2).center.y with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$2)
Replacing struct member reference *((const struct Circle*) circles + (number~) main::$3).radius with member unwinding reference *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$3)
Replacing struct member reference *((const struct Circle*) circles + (number~) main::$4).center.x with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4)
Replacing struct member reference *((const struct Circle*) circles + (number~) main::$5).center.y with member unwinding reference *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5)
Replacing struct member reference *((const struct Circle*) circles + (number~) main::$6).radius with member unwinding reference *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$6)
Replacing struct member reference *((struct Circle*) main::ptr).center.x with member unwinding reference *((byte*~) main::$8)
Replacing struct member reference *((struct Circle*) main::ptr).center.y with member unwinding reference *((byte*~) main::$10)
Culled Empty Block (label) main::@2
CONTROL FLOW GRAPH SSA
@ -28,27 +22,17 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @1
(number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
(struct Point*~) main::$7 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$15 ← (byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$15 + (number~) main::$1) ← (number) 2
*((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$1) ← (number) 2
(number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
(struct Point*~) main::$8 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$16 ← (byte*)(struct Point*~) main::$8 + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$16 + (number~) main::$2) ← (number) 3
*((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$2) ← (number) 3
(number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
(byte*~) main::$9 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
*((byte*~) main::$9 + (number~) main::$3) ← (number) 5
*((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$3) ← (number) 5
(number~) main::$4 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
(struct Point*~) main::$10 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$17 ← (byte*)(struct Point*~) main::$10 + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$17 + (number~) main::$4) ← (number) 8
*((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4) ← (number) 8
(number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
(struct Point*~) main::$11 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$18 ← (byte*)(struct Point*~) main::$11 + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$18 + (number~) main::$5) ← (number) 9
*((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5) ← (number) 9
(number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
(byte*~) main::$12 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
*((byte*~) main::$12 + (number~) main::$6) ← (number) $f
*((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (number~) main::$6) ← (number) $f
(byte) main::idx#0 ← (byte) 0
(struct Circle*) main::ptr#0 ← (const struct Circle*) circles
(byte) main::i#0 ← (byte) 0
@ -57,12 +41,12 @@ main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(byte) main::idx#3 ← phi( main/(byte) main::idx#0 main::@1/(byte) main::idx#2 )
(struct Circle*) main::ptr#2 ← phi( main/(struct Circle*) main::ptr#0 main::@1/(struct Circle*) main::ptr#1 )
(struct Point*~) main::$13 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$19 ← (byte*)(struct Point*~) main::$13 + (const byte) OFFSET_STRUCT_POINT_X
(byte) main::x#0 ← *((byte*~) main::$19)
(struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$20 ← (byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y
(byte) main::y#0 ← *((byte*~) main::$20)
(struct Point*~) main::$7 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$8 ← (byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
(byte) main::x#0 ← *((byte*~) main::$8)
(struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
(byte*~) main::$10 ← (byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y
(byte) main::y#0 ← *((byte*~) main::$10)
*((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0
(byte) main::idx#1 ← ++ (byte) main::idx#3
*((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0
@ -100,25 +84,15 @@ SYMBOL TABLE SSA
(void()) main()
(bool~) main::$0
(number~) main::$1
(struct Point*~) main::$10
(struct Point*~) main::$11
(byte*~) main::$12
(struct Point*~) main::$13
(struct Point*~) main::$14
(byte*~) main::$15
(byte*~) main::$16
(byte*~) main::$17
(byte*~) main::$18
(byte*~) main::$19
(byte*~) main::$10
(number~) main::$2
(byte*~) main::$20
(number~) main::$3
(number~) main::$4
(number~) main::$5
(number~) main::$6
(struct Point*~) main::$7
(struct Point*~) main::$8
(byte*~) main::$9
(byte*~) main::$8
(struct Point*~) main::$9
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*)(number) $400
@ -142,29 +116,29 @@ SYMBOL TABLE SSA
Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) 2 in *((byte*~) main::$15 + (unumber~) main::$1) ← (number) 2
Adding number conversion cast (unumber) 2 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$1) ← (number) 2
Adding number conversion cast (unumber) 0 in (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) 3 in *((byte*~) main::$16 + (unumber~) main::$2) ← (number) 3
Adding number conversion cast (unumber) 3 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$2) ← (number) 3
Adding number conversion cast (unumber) 0 in (number~) main::$3 ← (number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) 5 in *((byte*~) main::$9 + (unumber~) main::$3) ← (number) 5
Adding number conversion cast (unumber) 5 in *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$3) ← (number) 5
Adding number conversion cast (unumber) 1 in (number~) main::$4 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) main::$4 in (number~) main::$4 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) 8 in *((byte*~) main::$17 + (unumber~) main::$4) ← (number) 8
Adding number conversion cast (unumber) 8 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$4) ← (number) 8
Adding number conversion cast (unumber) 1 in (number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) main::$5 in (number~) main::$5 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) 9 in *((byte*~) main::$18 + (unumber~) main::$5) ← (number) 9
Adding number conversion cast (unumber) 9 in *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$5) ← (number) 9
Adding number conversion cast (unumber) 1 in (number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) main::$6 in (number~) main::$6 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Adding number conversion cast (unumber) $f in *((byte*~) main::$12 + (unumber~) main::$6) ← (number) $f
Adding number conversion cast (unumber) $f in *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$6) ← (number) $f
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast *((byte*~) main::$15 + (unumber~) main::$1) ← (unumber)(number) 2
Inlining cast *((byte*~) main::$16 + (unumber~) main::$2) ← (unumber)(number) 3
Inlining cast *((byte*~) main::$9 + (unumber~) main::$3) ← (unumber)(number) 5
Inlining cast *((byte*~) main::$17 + (unumber~) main::$4) ← (unumber)(number) 8
Inlining cast *((byte*~) main::$18 + (unumber~) main::$5) ← (unumber)(number) 9
Inlining cast *((byte*~) main::$12 + (unumber~) main::$6) ← (unumber)(number) $f
Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$1) ← (unumber)(number) 2
Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$2) ← (unumber)(number) 3
Inlining cast *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$3) ← (unumber)(number) 5
Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$4) ← (unumber)(number) 8
Inlining cast *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$5) ← (unumber)(number) 9
Inlining cast *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (unumber~) main::$6) ← (unumber)(number) $f
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -199,68 +173,51 @@ Inferred type updated to byte in (unumber~) main::$3 ← (byte) 0 * (const byte)
Inferred type updated to byte in (unumber~) main::$4 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Inferred type updated to byte in (unumber~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Inferred type updated to byte in (unumber~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Simple Condition (bool~) main::$0 [39] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
Simple Condition (bool~) main::$0 [29] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [0] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [1] (struct Point*~) main::$7 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [5] (struct Point*~) main::$8 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant right-side identified [8] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [9] (byte*~) main::$9 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
Constant right-side identified [11] (byte~) main::$4 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [12] (struct Point*~) main::$10 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant right-side identified [15] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [16] (struct Point*~) main::$11 ← (struct Point*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant right-side identified [19] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [20] (byte*~) main::$12 ← (byte*)(const struct Circle*) circles + (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
Constant right-side identified [2] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [4] (byte~) main::$3 ← (byte) 0 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [6] (byte~) main::$4 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [8] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Constant right-side identified [10] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_CIRCLE
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$1 = 0*SIZEOF_STRUCT_CIRCLE
Constant (const struct Point*) main::$7 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
Constant (const byte) main::$2 = 0*SIZEOF_STRUCT_CIRCLE
Constant (const struct Point*) main::$8 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
Constant (const byte) main::$3 = 0*SIZEOF_STRUCT_CIRCLE
Constant (const byte*) main::$9 = (byte*)circles+OFFSET_STRUCT_CIRCLE_RADIUS
Constant (const byte) main::$4 = 1*SIZEOF_STRUCT_CIRCLE
Constant (const struct Point*) main::$10 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
Constant (const byte) main::$5 = 1*SIZEOF_STRUCT_CIRCLE
Constant (const struct Point*) main::$11 = (struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER
Constant (const byte) main::$6 = 1*SIZEOF_STRUCT_CIRCLE
Constant (const byte*) main::$12 = (byte*)circles+OFFSET_STRUCT_CIRCLE_RADIUS
Constant (const byte) main::idx#0 = 0
Constant (const struct Circle*) main::ptr#0 = circles
Constant (const byte) main::i#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Constant value identified (byte*)main::$7 in [2] (byte*~) main::$15 ← (byte*)(const struct Point*) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
Constant value identified (byte*)main::$8 in [6] (byte*~) main::$16 ← (byte*)(const struct Point*) main::$8 + (const byte) OFFSET_STRUCT_POINT_Y
Constant value identified (byte*)main::$10 in [13] (byte*~) main::$17 ← (byte*)(const struct Point*) main::$10 + (const byte) OFFSET_STRUCT_POINT_X
Constant value identified (byte*)main::$11 in [17] (byte*~) main::$18 ← (byte*)(const struct Point*) main::$11 + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantValues
Resolved ranged next value [37] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [39] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
Converting *(pointer+n) to pointer[n] [28] (byte) main::x#0 ← *((byte*~) main::$19) -- *((byte*)main::$13 + OFFSET_STRUCT_POINT_X)
Converting *(pointer+n) to pointer[n] [31] (byte) main::y#0 ← *((byte*~) main::$20) -- *((byte*)main::$14 + OFFSET_STRUCT_POINT_Y)
Resolved ranged next value [27] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [29] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
Converting *(pointer+n) to pointer[n] [18] (byte) main::x#0 ← *((byte*~) main::$8) -- *((byte*)main::$7 + OFFSET_STRUCT_POINT_X)
Converting *(pointer+n) to pointer[n] [21] (byte) main::y#0 ← *((byte*~) main::$10) -- *((byte*)main::$9 + OFFSET_STRUCT_POINT_Y)
Successful SSA optimization Pass2InlineDerefIdx
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_CIRCLE in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_CIRCLE in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_CIRCLE in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero (byte*)circles in
Simplifying expression containing zero (byte*)circles in
Simplifying expression containing zero (byte*)main::$7 in [2] (byte*~) main::$15 ← (byte*)(const struct Point*) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
Simplifying expression containing zero main::$15 in [3] *((byte*~) main::$15 + (const byte) main::$1) ← (byte) 2
Simplifying expression containing zero main::$16 in [7] *((byte*~) main::$16 + (const byte) main::$2) ← (byte) 3
Simplifying expression containing zero main::$9 in [10] *((const byte*) main::$9 + (const byte) main::$3) ← (byte) 5
Simplifying expression containing zero (byte*)main::$10 in [13] (byte*~) main::$17 ← (byte*)(const struct Point*) main::$10 + (const byte) OFFSET_STRUCT_POINT_X
Simplifying expression containing zero (byte*)main::$13 in [27] (byte*~) main::$19 ← (byte*)(struct Point*~) main::$13 + (const byte) OFFSET_STRUCT_POINT_X
Simplifying expression containing zero (byte*)main::$13 in [28] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$13 + (const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+OFFSET_STRUCT_POINT_X in [1] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$1) ← (byte) 2
Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER in [1] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+OFFSET_STRUCT_POINT_Y in [3] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$2) ← (byte) 3
Simplifying expression containing zero (byte*)circles+OFFSET_STRUCT_CIRCLE_RADIUS in [5] *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (const byte) main::$3) ← (byte) 5
Simplifying expression containing zero (byte*)circles in [5] *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS) ← (byte) 5
Simplifying expression containing zero (byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER in [7] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$4) ← (byte) 8
Simplifying expression containing zero (byte*)circles in [11] *((byte*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_RADIUS + (const byte) main::$6) ← (byte) $f
Simplifying expression containing zero (byte*)main::$7 in [17] (byte*~) main::$8 ← (byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X
Simplifying expression containing zero (byte*)main::$7 in [18] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$7 + (const byte) OFFSET_STRUCT_POINT_X)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (byte*~) main::$19 and assignment [12] (byte*~) main::$19 ← (byte*)(struct Point*~) main::$13
Eliminating unused variable (byte*~) main::$20 and assignment [15] (byte*~) main::$20 ← (byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y
Eliminating unused variable (byte*~) main::$8 and assignment [8] (byte*~) main::$8 ← (byte*)(struct Point*~) main::$7
Eliminating unused variable (byte*~) main::$10 and assignment [11] (byte*~) main::$10 ← (byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y
Eliminating unused constant (const byte) main::$1
Eliminating unused constant (const byte) main::$2
Eliminating unused constant (const byte) main::$3
Eliminating unused constant (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Eliminating unused constant (const byte) OFFSET_STRUCT_CIRCLE_RADIUS
Successful SSA optimization PassNEliminateUnusedVars
Adding number conversion cast (unumber) 2 in if((byte) main::i#1!=(number) 2) goto main::@1
Successful SSA optimization PassNAddNumberTypeConversions
@ -268,37 +225,19 @@ Simplifying constant integer cast 2
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 2
Successful SSA optimization PassNFinalizeNumberTypeConversions
Constant right-side identified [2] (byte*~) main::$16 ← (byte*)(const struct Point*) main::$8 + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [7] (byte*~) main::$18 ← (byte*)(const struct Point*) main::$11 + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$15 = (byte*)main::$7
Constant (const byte*) main::$16 = (byte*)main::$8+OFFSET_STRUCT_POINT_Y
Constant (const byte*) main::$17 = (byte*)main::$10
Constant (const byte*) main::$18 = (byte*)main::$11+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Converting *(pointer+n) to pointer[n] [12] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$13) -- *((byte*)(struct Point*)main::ptr#2 + OFFSET_STRUCT_CIRCLE_CENTER)
Converting *(pointer+n) to pointer[n] [8] (byte) main::x#0 ← *((byte*)(struct Point*~) main::$7) -- *((byte*)(struct Point*)main::ptr#2 + OFFSET_STRUCT_CIRCLE_CENTER)
Successful SSA optimization Pass2InlineDerefIdx
Eliminating unused variable (struct Point*~) main::$13 and assignment [7] (struct Point*~) main::$13 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
Eliminating unused variable (struct Point*~) main::$7 and assignment [7] (struct Point*~) main::$7 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
Successful SSA optimization PassNEliminateUnusedVars
Inlining constant with var siblings (const byte) main::idx#0
Inlining constant with var siblings (const struct Circle*) main::ptr#0
Inlining constant with var siblings (const byte) main::i#0
Constant inlined main::$12 = (byte*)(const struct Circle*) circles
Constant inlined main::ptr#0 = (const struct Circle*) circles
Constant inlined main::$15 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant inlined main::$10 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant inlined main::$11 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant inlined main::idx#0 = (byte) 0
Constant inlined main::$16 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$17 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant inlined main::$18 = (byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$5 = (byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE
Constant inlined main::i#0 = (byte) 0
Constant inlined main::$6 = (byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE
Constant inlined main::idx#0 = (byte) 0
Constant inlined main::ptr#0 = (const struct Circle*) circles
Constant inlined main::$4 = (byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE
Constant inlined main::$9 = (byte*)(const struct Circle*) circles
Constant inlined main::$7 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
Constant inlined main::$8 = (struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *((byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+1*SIZEOF_STRUCT_CIRCLE)
Consolidated array index constant in *((byte*)(struct Point*)circles+OFFSET_STRUCT_CIRCLE_CENTER+OFFSET_STRUCT_POINT_Y+1*SIZEOF_STRUCT_CIRCLE)
@ -348,8 +287,8 @@ main::@1: scope:[main] from main main::@1
[10] (byte) main::idx#3 ← phi( main/(byte) 0 main::@1/(byte) main::idx#2 )
[10] (struct Circle*) main::ptr#2 ← phi( main/(const struct Circle*) circles main::@1/(struct Circle*) main::ptr#1 )
[11] (byte) main::x#0 ← *((byte*)(struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER)
[12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
[13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y)
[12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER
[13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y)
[14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0
[15] (byte) main::idx#1 ← ++ (byte) main::idx#3
[16] *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0
@ -369,7 +308,7 @@ VARIABLE REGISTER WEIGHTS
(byte) Point::x
(byte) Point::y
(void()) main()
(struct Point*~) main::$14 11.0
(struct Point*~) main::$9 11.0
(byte) main::i
(byte) main::i#1 16.5
(byte) main::i#2 2.4444444444444446
@ -390,7 +329,7 @@ Initial phi equivalence classes
[ main::idx#3 main::idx#2 ]
[ main::i#2 main::i#1 ]
Added variable main::x#0 to live range equivalence class [ main::x#0 ]
Added variable main::$14 to live range equivalence class [ main::$14 ]
Added variable main::$9 to live range equivalence class [ main::$9 ]
Added variable main::y#0 to live range equivalence class [ main::y#0 ]
Added variable main::idx#1 to live range equivalence class [ main::idx#1 ]
Complete equivalence classes
@ -398,14 +337,14 @@ Complete equivalence classes
[ main::idx#3 main::idx#2 ]
[ main::i#2 main::i#1 ]
[ main::x#0 ]
[ main::$14 ]
[ main::$9 ]
[ main::y#0 ]
[ main::idx#1 ]
Allocated zp[2]:2 [ main::ptr#2 main::ptr#1 ]
Allocated zp[1]:4 [ main::idx#3 main::idx#2 ]
Allocated zp[1]:5 [ main::i#2 main::i#1 ]
Allocated zp[1]:6 [ main::x#0 ]
Allocated zp[2]:7 [ main::$14 ]
Allocated zp[2]:7 [ main::$9 ]
Allocated zp[1]:9 [ main::y#0 ]
Allocated zp[1]:10 [ main::idx#1 ]
@ -438,7 +377,7 @@ __bend:
// main
main: {
.label SCREEN = $400
.label __14 = 7
.label __9 = 7
.label x = 6
.label y = 9
.label idx = $a
@ -489,17 +428,17 @@ main: {
ldy #OFFSET_STRUCT_CIRCLE_CENTER
lda (ptr),y
sta.z x
// [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1
// [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1
lda #OFFSET_STRUCT_CIRCLE_CENTER
clc
adc.z ptr
sta.z __14
sta.z __9
lda #0
adc.z ptr+1
sta.z __14+1
// [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuz1=pbuz2_derefidx_vbuc1
sta.z __9+1
// [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuz1=pbuz2_derefidx_vbuc1
ldy #OFFSET_STRUCT_POINT_Y
lda (__14),y
lda (__9),y
sta.z y
// [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 -- pbuc1_derefidx_vbuz1=vbuz2
lda.z x
@ -552,9 +491,9 @@ Removing always clobbered register reg byte a as potential for zp[1]:4 [ main::i
Removing always clobbered register reg byte y as potential for zp[1]:4 [ main::idx#3 main::idx#2 ]
Removing always clobbered register reg byte a as potential for zp[1]:5 [ main::i#2 main::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:5 [ main::i#2 main::i#1 ]
Statement [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ) always clobbers reg byte a
Statement [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp[1]:6 [ main::x#0 ]
Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y
Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y
Removing always clobbered register reg byte y as potential for zp[1]:6 [ main::x#0 ]
Statement [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ) always clobbers reg byte a
Removing always clobbered register reg byte a as potential for zp[1]:9 [ main::y#0 ]
@ -568,8 +507,8 @@ Statement [7] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte
Statement [8] *((byte*)(struct Point*)(const struct Circle*) circles+(const byte) OFFSET_STRUCT_CIRCLE_CENTER+(const byte) OFFSET_STRUCT_POINT_Y+(byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [9] *((byte*)(const struct Circle*) circles+(byte) 1*(const byte) SIZEOF_STRUCT_CIRCLE) ← (byte) $f [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [11] (byte) main::x#0 ← *((byte*)(struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 ] ) always clobbers reg byte a reg byte y
Statement [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$14 ] ) always clobbers reg byte a
Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y
Statement [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::$9 ] ) always clobbers reg byte a
Statement [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::x#0 main::y#0 ] ) always clobbers reg byte a reg byte y
Statement [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ( main:2 [ main::ptr#2 main::idx#3 main::i#2 main::y#0 ] ) always clobbers reg byte a
Statement [16] *((const byte*) main::SCREEN + (byte) main::idx#1) ← (byte) main::y#0 [ main::ptr#2 main::i#2 main::idx#1 ] ( main:2 [ main::ptr#2 main::i#2 main::idx#1 ] ) always clobbers reg byte a
Statement [18] (struct Circle*) main::ptr#1 ← (struct Circle*) main::ptr#2 + (const byte) SIZEOF_STRUCT_CIRCLE [ main::i#2 main::ptr#1 main::idx#2 ] ( main:2 [ main::i#2 main::ptr#1 main::idx#2 ] ) always clobbers reg byte a
@ -577,17 +516,17 @@ Potential registers zp[2]:2 [ main::ptr#2 main::ptr#1 ] : zp[2]:2 ,
Potential registers zp[1]:4 [ main::idx#3 main::idx#2 ] : zp[1]:4 , reg byte x ,
Potential registers zp[1]:5 [ main::i#2 main::i#1 ] : zp[1]:5 , reg byte x ,
Potential registers zp[1]:6 [ main::x#0 ] : zp[1]:6 , reg byte x ,
Potential registers zp[2]:7 [ main::$14 ] : zp[2]:7 ,
Potential registers zp[2]:7 [ main::$9 ] : zp[2]:7 ,
Potential registers zp[1]:9 [ main::y#0 ] : zp[1]:9 , reg byte x , reg byte y ,
Potential registers zp[1]:10 [ main::idx#1 ] : zp[1]:10 , reg byte x , reg byte y ,
REGISTER UPLIFT SCOPES
Uplift Scope [main] 18.94: zp[1]:5 [ main::i#2 main::i#1 ] 16.5: zp[1]:10 [ main::idx#1 ] 12.1: zp[1]:4 [ main::idx#3 main::idx#2 ] 11: zp[2]:7 [ main::$14 ] 10.08: zp[2]:2 [ main::ptr#2 main::ptr#1 ] 7.33: zp[1]:6 [ main::x#0 ] 7.33: zp[1]:9 [ main::y#0 ]
Uplift Scope [main] 18.94: zp[1]:5 [ main::i#2 main::i#1 ] 16.5: zp[1]:10 [ main::idx#1 ] 12.1: zp[1]:4 [ main::idx#3 main::idx#2 ] 11: zp[2]:7 [ main::$9 ] 10.08: zp[2]:2 [ main::ptr#2 main::ptr#1 ] 7.33: zp[1]:6 [ main::x#0 ] 7.33: zp[1]:9 [ main::y#0 ]
Uplift Scope [Point]
Uplift Scope [Circle]
Uplift Scope []
Uplifting [main] best 1184 combination zp[1]:5 [ main::i#2 main::i#1 ] reg byte x [ main::idx#1 ] reg byte x [ main::idx#3 main::idx#2 ] zp[2]:7 [ main::$14 ] zp[2]:2 [ main::ptr#2 main::ptr#1 ] zp[1]:6 [ main::x#0 ] reg byte y [ main::y#0 ]
Uplifting [main] best 1184 combination zp[1]:5 [ main::i#2 main::i#1 ] reg byte x [ main::idx#1 ] reg byte x [ main::idx#3 main::idx#2 ] zp[2]:7 [ main::$9 ] zp[2]:2 [ main::ptr#2 main::ptr#1 ] zp[1]:6 [ main::x#0 ] reg byte y [ main::y#0 ]
Uplifting [Point] best 1184 combination
Uplifting [Circle] best 1184 combination
Uplifting [] best 1184 combination
@ -597,7 +536,7 @@ Attempting to uplift remaining variables inzp[1]:6 [ main::x#0 ]
Uplifting [main] best 1184 combination zp[1]:6 [ main::x#0 ]
Allocated (was zp[1]:5) zp[1]:4 [ main::i#2 main::i#1 ]
Allocated (was zp[1]:6) zp[1]:5 [ main::x#0 ]
Allocated (was zp[2]:7) zp[2]:6 [ main::$14 ]
Allocated (was zp[2]:7) zp[2]:6 [ main::$9 ]
ASSEMBLER BEFORE OPTIMIZATION
// File Comments
@ -627,7 +566,7 @@ __bend:
// main
main: {
.label SCREEN = $400
.label __14 = 6
.label __9 = 6
.label x = 5
.label ptr = 2
.label i = 4
@ -674,17 +613,17 @@ main: {
ldy #OFFSET_STRUCT_CIRCLE_CENTER
lda (ptr),y
sta.z x
// [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1
// [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1
lda #OFFSET_STRUCT_CIRCLE_CENTER
clc
adc.z ptr
sta.z __14
sta.z __9
lda #0
adc.z ptr+1
sta.z __14+1
// [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1
sta.z __9+1
// [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1
ldy #OFFSET_STRUCT_POINT_Y
lda (__14),y
lda (__9),y
tay
// [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 -- pbuc1_derefidx_vbuxx=vbuz1
lda.z x
@ -759,7 +698,7 @@ FINAL SYMBOL TABLE
(const byte) SIZEOF_STRUCT_CIRCLE = (byte) 3
(const struct Circle*) circles[(number) 2] = { fill( 2, 0) }
(void()) main()
(struct Point*~) main::$14 zp[2]:6 11.0
(struct Point*~) main::$9 zp[2]:6 11.0
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*) 1024
@ -782,7 +721,7 @@ zp[2]:2 [ main::ptr#2 main::ptr#1 ]
reg byte x [ main::idx#3 main::idx#2 ]
zp[1]:4 [ main::i#2 main::i#1 ]
zp[1]:5 [ main::x#0 ]
zp[2]:6 [ main::$14 ]
zp[2]:6 [ main::$9 ]
reg byte y [ main::y#0 ]
reg byte x [ main::idx#1 ]
@ -809,7 +748,7 @@ Score: 1082
// main
main: {
.label SCREEN = $400
.label __14 = 6
.label __9 = 6
.label x = 5
.label ptr = 2
.label i = 4
@ -860,17 +799,17 @@ main: {
lda (ptr),y
sta.z x
// y = ptr->center.y
// [12] (struct Point*~) main::$14 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1
// [12] (struct Point*~) main::$9 ← (struct Point*)(struct Circle*) main::ptr#2 + (const byte) OFFSET_STRUCT_CIRCLE_CENTER -- pssz1=pssz2_plus_vbuc1
tya
clc
adc.z ptr
sta.z __14
sta.z __9
lda #0
adc.z ptr+1
sta.z __14+1
// [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$14 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1
sta.z __9+1
// [13] (byte) main::y#0 ← *((byte*)(struct Point*~) main::$9 + (const byte) OFFSET_STRUCT_POINT_Y) -- vbuyy=pbuz1_derefidx_vbuc1
ldy #OFFSET_STRUCT_POINT_Y
lda (__14),y
lda (__9),y
tay
// SCREEN[idx++] = x
// [14] *((const byte*) main::SCREEN + (byte) main::idx#3) ← (byte) main::x#0 -- pbuc1_derefidx_vbuxx=vbuz1

4
src/test/ref/struct-ptr-15.sym
View File

@ -10,7 +10,7 @@
(const byte) SIZEOF_STRUCT_CIRCLE = (byte) 3
(const struct Circle*) circles[(number) 2] = { fill( 2, 0) }
(void()) main()
(struct Point*~) main::$14 zp[2]:6 11.0
(struct Point*~) main::$9 zp[2]:6 11.0
(label) main::@1
(label) main::@return
(const byte*) main::SCREEN = (byte*) 1024
@ -33,6 +33,6 @@ zp[2]:2 [ main::ptr#2 main::ptr#1 ]
reg byte x [ main::idx#3 main::idx#2 ]
zp[1]:4 [ main::i#2 main::i#1 ]
zp[1]:5 [ main::x#0 ]
zp[2]:6 [ main::$14 ]
zp[2]:6 [ main::$9 ]
reg byte y [ main::y#0 ]
reg byte x [ main::idx#1 ]

4
src/test/ref/struct-ptr-20.log
View File

@ -1,7 +1,7 @@
Fixing pointer addition (struct Setting*~) main::$2 ← (const struct Setting*) settings + (byte) main::len
Fixing pointer increment (struct Setting*) main::setting ← ++ (struct Setting*) main::setting
Rewriting struct pointer member access *((struct Setting*) main::setting).off
Rewriting struct pointer member access *((struct Setting*) main::setting).id
Replacing struct member reference *((struct Setting*) main::setting).off with member unwinding reference *((byte*~) main::$7)
Replacing struct member reference *((struct Setting*) main::setting).id with member unwinding reference *((byte*~) main::$8)
Warning! Adding boolean cast to non-boolean sub-expression *((byte*~) main::$7)
Culled Empty Block (label) main::@5
Culled Empty Block (label) main::@3

4
src/test/ref/struct-ptr-21.log
View File

@ -2,8 +2,8 @@ Fixing constant pointer addition (const word*) seq+(number) 0
Fixing constant pointer addition (const struct Setting*) settings+(number) 0
Fixing pointer array-indexing *(*((struct Setting*) main::setting).buf + (byte) main::i)
Fixing pointer array-indexing *((const word*) SCREEN + (byte) main::i)
Rewriting struct pointer member access *((struct Setting*) main::setting).len
Rewriting struct pointer member access *((struct Setting*) main::setting).buf
Replacing struct member reference *((struct Setting*) main::setting).len with member unwinding reference *((byte*~) main::$2)
Replacing struct member reference *((struct Setting*) main::setting).buf with member unwinding reference *((word**~) main::$3)
Identified constant variable (struct Setting*) main::setting
Identified constant variable (byte) main::idx
Culled Empty Block (label) main::@4

6
src/test/ref/struct-ptr-22.log
View File

@ -3,9 +3,9 @@ Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot +
Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1
Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
Rewriting struct pointer member access *((struct fileentry*) file).bufEdit
Rewriting struct pointer member access *((struct fileentry*) file).bufEdit
Rewriting struct pointer member access *((struct fileentry*) file).bufEdit
Replacing struct member reference *((struct fileentry*) file).bufEdit with member unwinding reference *((byte**~) main::$8)
Replacing struct member reference *((struct fileentry*) file).bufEdit with member unwinding reference *((byte**~) main::$9)
Replacing struct member reference *((struct fileentry*) file).bufEdit with member unwinding reference *((byte**~) main::$10)
Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)

8
src/test/ref/struct-ptr-23.log
View File

@ -4,10 +4,10 @@ Fixing struct type size struct Person to 5
Fixing struct type SIZE_OF struct Person to 5
Fixing struct type SIZE_OF struct Person to 5
Fixing pointer increment (struct Person*) main::person ← ++ (struct Person*) main::person
Rewriting struct pointer member access *((struct Person*) print_person::person).id
Rewriting struct pointer member access *((struct Person*) print_person::person).initials
Rewriting struct pointer member access *((struct Person*) print_person::person).initials
Rewriting struct pointer member access *((struct Person*) print_person::person).initials
Replacing struct member reference *((struct Person*) print_person::person).id with member unwinding reference *((byte*~) print_person::$1)
Replacing struct member reference *((struct Person*) print_person::person).initials with member unwinding reference (byte*~) print_person::$2
Replacing struct member reference *((struct Person*) print_person::person).initials with member unwinding reference (byte*~) print_person::$3
Replacing struct member reference *((struct Person*) print_person::person).initials with member unwinding reference (byte*~) print_person::$4
CONTROL FLOW GRAPH SSA
@begin: scope:[] from

4
src/test/ref/struct-ptr-26.log
View File

@ -3,8 +3,8 @@ Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot +
Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1
Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
Rewriting struct pointer member access *((struct fileentry*) main::file).bufEdit
Rewriting struct pointer member access *((struct fileentry*) main::file).bufEdit
Replacing struct member reference *((struct fileentry*) main::file).bufEdit with member unwinding reference *((byte**~) main::$3)
Replacing struct member reference *((struct fileentry*) main::file).bufEdit with member unwinding reference *((byte**~) main::$4)
Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)

8
src/test/ref/struct-ptr-3.log
View File

@ -1,8 +1,8 @@
Fixing pointer increment (struct Point*) points ← ++ (struct Point*) points
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).y
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).y
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$0)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$1)
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$2)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$3)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from

6
src/test/ref/struct-ptr-31.log
View File

@ -3,9 +3,9 @@ Fixing struct type size struct Person to 17
Fixing struct type SIZE_OF struct Person to 17
Fixing struct type SIZE_OF struct Person to 17
Fixing constant pointer addition (const struct Person*) persons+(number) 1
Rewriting struct pointer member access *((struct Person*) print_person::person).id
Rewriting struct pointer member access *((struct Person*) print_person::person).name
Rewriting struct pointer member access *((struct Person*) print_person::person).name
Replacing struct member reference *((struct Person*) print_person::person).id with member unwinding reference *((byte*~) print_person::$0)
Replacing struct member reference *((struct Person*) print_person::person).name with member unwinding reference (byte*~) print_person::$1
Replacing struct member reference *((struct Person*) print_person::person).name with member unwinding reference (byte*~) print_person::$2
Warning! Adding boolean cast to non-boolean condition *((byte*~) print_person::$1 + (byte) print_person::i)
Culled Empty Block (label) print_person::@4
Culled Empty Block (label) print_person::@5

2
src/test/ref/struct-ptr-32.asm
View File

@ -15,7 +15,7 @@ main: {
lda #'a'
sta persons+OFFSET_STRUCT_PERSON_NAME+8
lda #'b'
sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
lda #<$141
sta persons+OFFSET_STRUCT_PERSON_AGE
lda #>$141

2
src/test/ref/struct-ptr-32.cfg
View File

@ -13,7 +13,7 @@ main: scope:[main] from @1
[4] *((byte*)(const struct Person*) persons) ← (byte) 7
[5] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) 9
[6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a'
[7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b'
[7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b'
[8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141
[9] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) $7b
[10] *((const byte*) main::SCREEN) ← *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8)

168
src/test/ref/struct-ptr-32.log
View File

@ -9,14 +9,14 @@ Fixing pointer array-indexing *((const struct Person*) persons + (number) 0)
Fixing pointer array-indexing *((const struct Person*) persons + (number) 1)
Fixing pointer array-indexing *((const struct Person*) persons + (number) 0)
Fixing pointer array-indexing *((const struct Person*) persons + (number) 1)
Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$0).id
Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$1).id
Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$2).name
Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$3).name
Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$4).age
Rewriting struct pointer member access *((const struct Person*) persons + (number~) main::$5).age
Rewriting struct pointer member access *((struct Person*) main::person).name
Rewriting struct pointer member access *((struct Person*) main::person).name
Replacing struct member reference *((const struct Person*) persons + (number~) main::$0).id with member unwinding reference *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$0)
Replacing struct member reference *((const struct Person*) persons + (number~) main::$1).id with member unwinding reference *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$1)
Replacing struct member reference *((const struct Person*) persons + (number~) main::$2).name with member unwinding reference (byte*~) main::$6
Replacing struct member reference *((const struct Person*) persons + (number~) main::$3).name with member unwinding reference (byte*~) main::$7
Replacing struct member reference *((const struct Person*) persons + (number~) main::$4).age with member unwinding reference *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$4)
Replacing struct member reference *((const struct Person*) persons + (number~) main::$5).age with member unwinding reference *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$5)
Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$8
Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$9
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -25,31 +25,25 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @1
(number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
(byte*~) main::$6 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
*((byte*~) main::$6 + (number~) main::$0) ← (number) 7
*((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$0) ← (number) 7
(number~) main::$1 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
(byte*~) main::$7 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
*((byte*~) main::$7 + (number~) main::$1) ← (number) 9
*((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (number~) main::$1) ← (number) 9
(number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
(byte*~) main::$8 ← (byte*)(const struct Person*) persons + (number~) main::$2
(byte*~) main::$9 ← (byte*~) main::$8 + (const byte) OFFSET_STRUCT_PERSON_NAME
*((byte*~) main::$9 + (number) 8) ← (byte) 'a'
(byte*~) main::$6 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (number~) main::$2
*((byte*~) main::$6 + (number) 8) ← (byte) 'a'
(number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
(byte*~) main::$10 ← (byte*)(const struct Person*) persons + (number~) main::$3
(byte*~) main::$11 ← (byte*~) main::$10 + (const byte) OFFSET_STRUCT_PERSON_NAME
*((byte*~) main::$11 + (number) 8) ← (byte) 'b'
(byte*~) main::$7 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (number~) main::$3
*((byte*~) main::$7 + (number) 8) ← (byte) 'b'
(number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
(word*~) main::$12 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
*((word*~) main::$12 + (number~) main::$4) ← (number) $141
*((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$4) ← (number) $141
(number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
(word*~) main::$13 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
*((word*~) main::$13 + (number~) main::$5) ← (number) $7b
*((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (number~) main::$5) ← (number) $7b
(struct Person*) main::person#0 ← (const struct Person*) persons
(byte*~) main::$14 ← (byte*)(struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
*((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$14 + (number) 8)
(byte*~) main::$8 ← (byte*)(struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
*((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$8 + (number) 8)
(struct Person*) main::person#1 ← (struct Person*) main::person#0 + (const byte) SIZEOF_STRUCT_PERSON
(byte*~) main::$15 ← (byte*)(struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
*((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$15 + (number) 8)
(byte*~) main::$9 ← (byte*)(struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
*((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$9 + (number) 8)
to:main::@return
main::@return: scope:[main] from main
return
@ -76,12 +70,6 @@ SYMBOL TABLE SSA
(void()) main()
(number~) main::$0
(number~) main::$1
(byte*~) main::$10
(byte*~) main::$11
(word*~) main::$12
(word*~) main::$13
(byte*~) main::$14
(byte*~) main::$15
(number~) main::$2
(number~) main::$3
(number~) main::$4
@ -99,31 +87,31 @@ SYMBOL TABLE SSA
Adding number conversion cast (unumber) 0 in (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) 7 in *((byte*~) main::$6 + (unumber~) main::$0) ← (number) 7
Adding number conversion cast (unumber) 7 in *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$0) ← (number) 7
Adding number conversion cast (unumber) 1 in (number~) main::$1 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) 9 in *((byte*~) main::$7 + (unumber~) main::$1) ← (number) 9
Adding number conversion cast (unumber) 9 in *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$1) ← (number) 9
Adding number conversion cast (unumber) 0 in (number~) main::$2 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) 8 in *((byte*~) main::$9 + (number) 8) ← (byte) 'a'
Adding number conversion cast (unumber) 8 in *((byte*~) main::$6 + (number) 8) ← (byte) 'a'
Adding number conversion cast (unumber) 1 in (number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) 8 in *((byte*~) main::$11 + (number) 8) ← (byte) 'b'
Adding number conversion cast (unumber) 8 in *((byte*~) main::$7 + (number) 8) ← (byte) 'b'
Adding number conversion cast (unumber) 0 in (number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) main::$4 in (number~) main::$4 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) $141 in *((word*~) main::$12 + (unumber~) main::$4) ← (number) $141
Adding number conversion cast (unumber) $141 in *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$4) ← (number) $141
Adding number conversion cast (unumber) 1 in (number~) main::$5 ← (number) 1 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) main::$5 in (number~) main::$5 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_PERSON
Adding number conversion cast (unumber) $7b in *((word*~) main::$13 + (unumber~) main::$5) ← (number) $7b
Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$14 + (number) 8)
Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$14 + (unumber)(number) 8)
Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$15 + (number) 8)
Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$15 + (unumber)(number) 8)
Adding number conversion cast (unumber) $7b in *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$5) ← (number) $7b
Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$8 + (number) 8)
Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$8 + (unumber)(number) 8)
Adding number conversion cast (unumber) 8 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$9 + (number) 8)
Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$9 + (unumber)(number) 8)
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast *((byte*~) main::$6 + (unumber~) main::$0) ← (unumber)(number) 7
Inlining cast *((byte*~) main::$7 + (unumber~) main::$1) ← (unumber)(number) 9
Inlining cast *((word*~) main::$12 + (unumber~) main::$4) ← (unumber)(number) $141
Inlining cast *((word*~) main::$13 + (unumber~) main::$5) ← (unumber)(number) $7b
Inlining cast *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$0) ← (unumber)(number) 7
Inlining cast *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (unumber~) main::$1) ← (unumber)(number) 9
Inlining cast *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$4) ← (unumber)(number) $141
Inlining cast *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (unumber~) main::$5) ← (unumber)(number) $7b
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -167,86 +155,66 @@ Inferred type updated to byte in (unumber~) main::$3 ← (byte) 1 * (const byte)
Inferred type updated to byte in (unumber~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
Inferred type updated to byte in (unumber~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [0] (byte~) main::$0 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [1] (byte*~) main::$6 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
Constant right-side identified [3] (byte~) main::$1 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [4] (byte*~) main::$7 ← (byte*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_ID
Constant right-side identified [6] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [10] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [14] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [15] (word*~) main::$12 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
Constant right-side identified [17] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [18] (word*~) main::$13 ← (word*)(const struct Person*) persons + (const byte) OFFSET_STRUCT_PERSON_AGE
Constant right-side identified [2] (byte~) main::$1 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [4] (byte~) main::$2 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [7] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [10] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [12] (byte~) main::$5 ← (byte) 1 * (const byte) SIZEOF_STRUCT_PERSON
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$0 = 0*SIZEOF_STRUCT_PERSON
Constant (const byte*) main::$6 = (byte*)persons+OFFSET_STRUCT_PERSON_ID
Constant (const byte) main::$1 = 1*SIZEOF_STRUCT_PERSON
Constant (const byte*) main::$7 = (byte*)persons+OFFSET_STRUCT_PERSON_ID
Constant (const byte) main::$2 = 0*SIZEOF_STRUCT_PERSON
Constant (const byte) main::$3 = 1*SIZEOF_STRUCT_PERSON
Constant (const byte) main::$4 = 0*SIZEOF_STRUCT_PERSON
Constant (const word*) main::$12 = (word*)persons+OFFSET_STRUCT_PERSON_AGE
Constant (const byte) main::$5 = 1*SIZEOF_STRUCT_PERSON
Constant (const word*) main::$13 = (word*)persons+OFFSET_STRUCT_PERSON_AGE
Constant (const struct Person*) main::person#0 = persons
Successful SSA optimization Pass2ConstantIdentification
Constant value identified (byte*)persons in [7] (byte*~) main::$8 ← (byte*)(const struct Person*) persons + (const byte) main::$2
Constant value identified (byte*)persons in [11] (byte*~) main::$10 ← (byte*)(const struct Person*) persons + (const byte) main::$3
Constant value identified (byte*)main::person#0 in [21] (byte*~) main::$14 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant value identified (byte*)main::person#0 in [15] (byte*~) main::$8 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
Successful SSA optimization Pass2ConstantValues
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_PERSON in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_PERSON in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_PERSON in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero (byte*)persons in
Simplifying expression containing zero (byte*)persons in
Simplifying expression containing zero main::$6 in [2] *((const byte*) main::$6 + (const byte) main::$0) ← (byte) 7
Simplifying expression containing zero (byte*)persons in [7] (byte*~) main::$8 ← (byte*)(const struct Person*) persons + (const byte) main::$2
Simplifying expression containing zero main::$12 in [16] *((const word*) main::$12 + (const byte) main::$4) ← (word) $141
Simplifying expression containing zero main::SCREEN in [22] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*~) main::$14 + (byte) 8)
Simplifying expression containing zero (byte*)persons+OFFSET_STRUCT_PERSON_ID in [1] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (const byte) main::$0) ← (byte) 7
Simplifying expression containing zero (byte*)persons in [1] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID) ← (byte) 7
Simplifying expression containing zero (byte*)persons in [3] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_ID + (const byte) main::$1) ← (byte) 9
Simplifying expression containing zero (byte*)persons+OFFSET_STRUCT_PERSON_NAME in [5] (byte*~) main::$6 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (const byte) main::$2
Simplifying expression containing zero (word*)persons+OFFSET_STRUCT_PERSON_AGE in [11] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE + (const byte) main::$4) ← (word) $141
Simplifying expression containing zero main::SCREEN in [16] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*~) main::$8 + (byte) 8)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) main::$0
Eliminating unused constant (const byte) main::$2
Eliminating unused constant (const byte) main::$4
Eliminating unused constant (const byte) OFFSET_STRUCT_PERSON_ID
Successful SSA optimization PassNEliminateUnusedVars
Constant right-side identified [5] (byte*~) main::$10 ← (byte*)(const struct Person*) persons + (const byte) main::$3
Constant right-side identified [10] (byte*~) main::$14 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant right-side identified [12] (struct Person*) main::person#1 ← (const struct Person*) main::person#0 + (const byte) SIZEOF_STRUCT_PERSON
Constant right-side identified [4] (byte*~) main::$7 ← (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME + (const byte) main::$3
Constant right-side identified [8] (byte*~) main::$8 ← (byte*)(const struct Person*) main::person#0 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant right-side identified [10] (struct Person*) main::person#1 ← (const struct Person*) main::person#0 + (const byte) SIZEOF_STRUCT_PERSON
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$8 = (byte*)persons
Constant (const byte*) main::$10 = (byte*)persons+main::$3
Constant (const byte*) main::$14 = (byte*)main::person#0+OFFSET_STRUCT_PERSON_NAME
Constant (const byte*) main::$6 = (byte*)persons+OFFSET_STRUCT_PERSON_NAME
Constant (const byte*) main::$7 = (byte*)persons+OFFSET_STRUCT_PERSON_NAME+main::$3
Constant (const byte*) main::$8 = (byte*)main::person#0+OFFSET_STRUCT_PERSON_NAME
Constant (const struct Person*) main::person#1 = main::person#0+SIZEOF_STRUCT_PERSON
Successful SSA optimization Pass2ConstantIdentification
Constant value identified (byte*)main::person#1 in [13] (byte*~) main::$15 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant value identified (byte*)main::person#1 in [11] (byte*~) main::$9 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
Successful SSA optimization Pass2ConstantValues
Constant right-side identified [2] (byte*~) main::$9 ← (const byte*) main::$8 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant right-side identified [4] (byte*~) main::$11 ← (const byte*) main::$10 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant right-side identified [9] (byte*~) main::$15 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
Constant right-side identified [7] (byte*~) main::$9 ← (byte*)(const struct Person*) main::person#1 + (const byte) OFFSET_STRUCT_PERSON_NAME
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$9 = main::$8+OFFSET_STRUCT_PERSON_NAME
Constant (const byte*) main::$11 = main::$10+OFFSET_STRUCT_PERSON_NAME
Constant (const byte*) main::$15 = (byte*)main::person#1+OFFSET_STRUCT_PERSON_NAME
Constant (const byte*) main::$9 = (byte*)main::person#1+OFFSET_STRUCT_PERSON_NAME
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with different constant siblings (const struct Person*) main::person#0
Constant inlined main::$12 = (word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE
Constant inlined main::$13 = (word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE
Constant inlined main::$14 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
Constant inlined main::$15 = (byte*)(const struct Person*) main::person#1+(const byte) OFFSET_STRUCT_PERSON_NAME
Constant inlined main::$10 = (byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON
Constant inlined main::$11 = (byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME
Constant inlined main::$1 = (byte) 1*(const byte) SIZEOF_STRUCT_PERSON
Constant inlined main::$5 = (byte) 1*(const byte) SIZEOF_STRUCT_PERSON
Constant inlined main::$6 = (byte*)(const struct Person*) persons
Constant inlined main::$6 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
Constant inlined main::$3 = (byte) 1*(const byte) SIZEOF_STRUCT_PERSON
Constant inlined main::$9 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
Constant inlined main::$7 = (byte*)(const struct Person*) persons
Constant inlined main::$9 = (byte*)(const struct Person*) main::person#1+(const byte) OFFSET_STRUCT_PERSON_NAME
Constant inlined main::$7 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON
Constant inlined main::person#0 = (const struct Person*) persons
Constant inlined main::$8 = (byte*)(const struct Person*) persons
Constant inlined main::$8 = (byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *((byte*)persons+1*SIZEOF_STRUCT_PERSON)
Consolidated array index constant in *((byte*)persons+OFFSET_STRUCT_PERSON_NAME+8)
Consolidated array index constant in *((byte*)persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8)
Consolidated array index constant in *((byte*)persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8)
Consolidated array index constant in *((word*)persons+OFFSET_STRUCT_PERSON_AGE+1*SIZEOF_STRUCT_PERSON)
Consolidated array index constant in *((byte*)persons+OFFSET_STRUCT_PERSON_NAME+8)
Consolidated array index constant in *((byte*)main::person#1+OFFSET_STRUCT_PERSON_NAME+8)
@ -282,7 +250,7 @@ main: scope:[main] from @1
[4] *((byte*)(const struct Person*) persons) ← (byte) 7
[5] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) 9
[6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a'
[7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b'
[7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b'
[8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141
[9] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) $7b
[10] *((const byte*) main::SCREEN) ← *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8)
@ -341,9 +309,9 @@ main: {
// [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a' -- _deref_pbuc1=vbuc2
lda #'a'
sta persons+OFFSET_STRUCT_PERSON_NAME+8
// [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2
// [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2
lda #'b'
sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
// [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 -- _deref_pwuc1=vwuc2
lda #<$141
sta persons+OFFSET_STRUCT_PERSON_AGE
@ -373,7 +341,7 @@ REGISTER UPLIFT POTENTIAL REGISTERS
Statement [4] *((byte*)(const struct Person*) persons) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [5] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a' [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [9] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON) ← (byte) $7b [ ] ( main:2 [ ] ) always clobbers reg byte a
Statement [10] *((const byte*) main::SCREEN) ← *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) [ ] ( main:2 [ ] ) always clobbers reg byte a
@ -426,9 +394,9 @@ main: {
// [6] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'a' -- _deref_pbuc1=vbuc2
lda #'a'
sta persons+OFFSET_STRUCT_PERSON_NAME+8
// [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2
// [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2
lda #'b'
sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
// [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 -- _deref_pwuc1=vwuc2
lda #<$141
sta persons+OFFSET_STRUCT_PERSON_AGE
@ -528,9 +496,9 @@ main: {
lda #'a'
sta persons+OFFSET_STRUCT_PERSON_NAME+8
// persons[1].name[8] = 'b'
// [7] *((byte*)(const struct Person*) persons+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2
// [7] *((byte*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_NAME+(byte) 1*(const byte) SIZEOF_STRUCT_PERSON+(byte) 8) ← (byte) 'b' -- _deref_pbuc1=vbuc2
lda #'b'
sta persons+1*SIZEOF_STRUCT_PERSON+OFFSET_STRUCT_PERSON_NAME+8
sta persons+OFFSET_STRUCT_PERSON_NAME+1*SIZEOF_STRUCT_PERSON+8
// persons[0].age = 321
// [8] *((word*)(const struct Person*) persons+(const byte) OFFSET_STRUCT_PERSON_AGE) ← (word) $141 -- _deref_pwuc1=vwuc2
lda #<$141

4
src/test/ref/struct-ptr-33.log
View File

@ -3,8 +3,8 @@ Fixing struct type size struct Person to 16
Fixing struct type SIZE_OF struct Person to 16
Fixing struct type SIZE_OF struct Person to 16
Fixing pointer increment (struct Person*) main::person ← ++ (struct Person*) main::person
Rewriting struct pointer member access *((struct Person*) main::person).name
Rewriting struct pointer member access *((struct Person*) main::person).name
Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$0
Replacing struct member reference *((struct Person*) main::person).name with member unwinding reference (byte*~) main::$1
CONTROL FLOW GRAPH SSA
@begin: scope:[] from

8
src/test/ref/struct-ptr-4.log
View File

@ -1,9 +1,9 @@
Fixing pointer increment (struct Point*) main::points ← ++ (struct Point*) main::points
Fixing pointer increment (struct Point*) main::points ← ++ (struct Point*) main::points
Rewriting struct pointer member access *((struct Point*) main::points).x
Rewriting struct pointer member access *((struct Point*) main::points).y
Rewriting struct pointer member access *((struct Point*) main::points).x
Rewriting struct pointer member access *((struct Point*) main::points).y
Replacing struct member reference *((struct Point*) main::points).x with member unwinding reference *((byte*~) main::$3)
Replacing struct member reference *((struct Point*) main::points).y with member unwinding reference *((byte*~) main::$4)
Replacing struct member reference *((struct Point*) main::points).x with member unwinding reference *((byte*~) main::$5)
Replacing struct member reference *((struct Point*) main::points).y with member unwinding reference *((byte*~) main::$6)
Identified constant variable (struct Point*) POINTS
Culled Empty Block (label) main::@4

20
src/test/ref/struct-ptr-5.log
View File

@ -1,16 +1,16 @@
Fixing struct type size struct Entry to 3
Fixing pointer addition (struct Entry*~) main::$0 ← (struct Entry*) ENTRIES + (number) 1
Fixing pointer addition (struct Entry*~) main::$1 ← (struct Entry*) ENTRIES + (number) 2
Rewriting struct pointer member access *((struct Entry*) main::entry0).next
Rewriting struct pointer member access *((struct Entry*) main::entry0).value
Rewriting struct pointer member access *((struct Entry*) main::entry2).next
Rewriting struct pointer member access *((struct Entry*) main::entry2).value
Rewriting struct pointer member access *((struct Entry*) main::entry1).next
Rewriting struct pointer member access *((struct Entry*) main::entry1).value
Rewriting struct pointer member access *((struct Entry*) main::entry).value
Rewriting struct pointer member access *((struct Entry*) main::entry).next
Rewriting struct pointer member access *((struct Entry*) main::entry).next
Rewriting struct pointer member access *((struct Entry*) main::entry).next
Replacing struct member reference *((struct Entry*) main::entry0).next with member unwinding reference *((struct Entry**~) main::$7)
Replacing struct member reference *((struct Entry*) main::entry0).value with member unwinding reference *((byte*~) main::$8)
Replacing struct member reference *((struct Entry*) main::entry2).next with member unwinding reference *((struct Entry**~) main::$9)
Replacing struct member reference *((struct Entry*) main::entry2).value with member unwinding reference *((byte*~) main::$10)
Replacing struct member reference *((struct Entry*) main::entry1).next with member unwinding reference *((struct Entry**~) main::$11)
Replacing struct member reference *((struct Entry*) main::entry1).value with member unwinding reference *((byte*~) main::$12)
Replacing struct member reference *((struct Entry*) main::entry).value with member unwinding reference *((byte*~) main::$13)
Replacing struct member reference *((struct Entry*) main::entry).next with member unwinding reference *((struct Entry**~) main::$14)
Replacing struct member reference *((struct Entry*) main::entry).next with member unwinding reference *((struct Entry**~) main::$15)
Replacing struct member reference *((struct Entry*) main::entry).next with member unwinding reference *((struct Entry**~) main::$16)
Warning! Adding boolean cast to non-boolean condition (struct Entry*) main::entry
Identified constant variable (struct Entry*) ENTRIES
Culled Empty Block (label) main::@4

8
src/test/ref/struct-ptr-6.log
View File

@ -1,8 +1,8 @@
Fixing pointer increment (struct Point*) points ← ++ (struct Point*) points
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).y
Rewriting struct pointer member access *((struct Point*) points).x
Rewriting struct pointer member access *((struct Point*) points).y
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$0)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$1)
Replacing struct member reference *((struct Point*) points).x with member unwinding reference *((byte*~) main::$2)
Replacing struct member reference *((struct Point*) points).y with member unwinding reference *((byte*~) main::$3)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from

130
src/test/ref/struct-ptr-7.log
View File

@ -6,14 +6,14 @@ Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
Fixing pointer array-indexing *((const struct Point*) points + (number) 0)
Fixing pointer array-indexing *((const struct Point*) points + (number) 1)
Fixing pointer array-indexing *((const struct Point*) points + (number) 1)
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$0).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$1).y
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$2).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$3).y
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$4).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$5).y
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$6).x
Rewriting struct pointer member access *((const struct Point*) points + (number~) main::$7).y
Replacing struct member reference *((const struct Point*) points + (number~) main::$0).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0)
Replacing struct member reference *((const struct Point*) points + (number~) main::$1).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1)
Replacing struct member reference *((const struct Point*) points + (number~) main::$2).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2)
Replacing struct member reference *((const struct Point*) points + (number~) main::$3).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3)
Replacing struct member reference *((const struct Point*) points + (number~) main::$4).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4)
Replacing struct member reference *((const struct Point*) points + (number~) main::$5).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5)
Replacing struct member reference *((const struct Point*) points + (number~) main::$6).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$6)
Replacing struct member reference *((const struct Point*) points + (number~) main::$7).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$7)
CONTROL FLOW GRAPH SSA
@begin: scope:[] from
@ -22,29 +22,21 @@ CONTROL FLOW GRAPH SSA
(void()) main()
main: scope:[main] from @1
(number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$8 + (number~) main::$0) ← (number) 2
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$0) ← (number) 2
(number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$9 + (number~) main::$1) ← (number) 3
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$1) ← (number) 3
(number~) main::$2 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$10 + (number~) main::$2) ← (number) 5
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$2) ← (number) 5
(number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$11 + (number~) main::$3) ← (number) 6
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$3) ← (number) 6
(number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$12 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$12 + (number~) main::$4)
*((const byte*) main::SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$4)
(number~) main::$5 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$13 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$13 + (number~) main::$5)
*((const byte*) main::SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$5)
(number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$14 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) main::SCREEN + (number) 3) ← *((byte*~) main::$14 + (number~) main::$6)
*((const byte*) main::SCREEN + (number) 3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (number~) main::$6)
(number~) main::$7 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$15 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) main::SCREEN + (number) 4) ← *((byte*~) main::$15 + (number~) main::$7)
*((const byte*) main::SCREEN + (number) 4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (number~) main::$7)
to:main::@return
main::@return: scope:[main] from main
return
@ -69,53 +61,45 @@ SYMBOL TABLE SSA
(void()) main()
(number~) main::$0
(number~) main::$1
(byte*~) main::$10
(byte*~) main::$11
(byte*~) main::$12
(byte*~) main::$13
(byte*~) main::$14
(byte*~) main::$15
(number~) main::$2
(number~) main::$3
(number~) main::$4
(number~) main::$5
(number~) main::$6
(number~) main::$7
(byte*~) main::$8
(byte*~) main::$9
(label) main::@return
(const byte*) main::SCREEN = (byte*)(number) $400
(const struct Point*) points[(number) 2] = { fill( 2, 0) }
Adding number conversion cast (unumber) 0 in (number~) main::$0 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 2 in *((byte*~) main::$8 + (unumber~) main::$0) ← (number) 2
Adding number conversion cast (unumber) 2 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (number) 2
Adding number conversion cast (unumber) 0 in (number~) main::$1 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$1 in (number~) main::$1 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 3 in *((byte*~) main::$9 + (unumber~) main::$1) ← (number) 3
Adding number conversion cast (unumber) 3 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (number) 3
Adding number conversion cast (unumber) 1 in (number~) main::$2 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$2 in (number~) main::$2 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 5 in *((byte*~) main::$10 + (unumber~) main::$2) ← (number) 5
Adding number conversion cast (unumber) 5 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2) ← (number) 5
Adding number conversion cast (unumber) 1 in (number~) main::$3 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$3 in (number~) main::$3 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 6 in *((byte*~) main::$11 + (unumber~) main::$3) ← (number) 6
Adding number conversion cast (unumber) 6 in *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3) ← (number) 6
Adding number conversion cast (unumber) 0 in (number~) main::$4 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$4 in (number~) main::$4 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*~) main::$12 + (unumber~) main::$4)
Adding number conversion cast (unumber) 0 in *((const byte*) main::SCREEN + (number) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$4)
Adding number conversion cast (unumber) 0 in (number~) main::$5 ← (number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$5 in (number~) main::$5 ← (unumber)(number) 0 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*~) main::$13 + (unumber~) main::$5)
Adding number conversion cast (unumber) 1 in *((const byte*) main::SCREEN + (number) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$5)
Adding number conversion cast (unumber) 1 in (number~) main::$6 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$6 in (number~) main::$6 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 3 in *((const byte*) main::SCREEN + (number) 3) ← *((byte*~) main::$14 + (unumber~) main::$6)
Adding number conversion cast (unumber) 3 in *((const byte*) main::SCREEN + (number) 3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$6)
Adding number conversion cast (unumber) 1 in (number~) main::$7 ← (number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) main::$7 in (number~) main::$7 ← (unumber)(number) 1 * (const byte) SIZEOF_STRUCT_POINT
Adding number conversion cast (unumber) 4 in *((const byte*) main::SCREEN + (number) 4) ← *((byte*~) main::$15 + (unumber~) main::$7)
Adding number conversion cast (unumber) 4 in *((const byte*) main::SCREEN + (number) 4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$7)
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast *((byte*~) main::$8 + (unumber~) main::$0) ← (unumber)(number) 2
Inlining cast *((byte*~) main::$9 + (unumber~) main::$1) ← (unumber)(number) 3
Inlining cast *((byte*~) main::$10 + (unumber~) main::$2) ← (unumber)(number) 5
Inlining cast *((byte*~) main::$11 + (unumber~) main::$3) ← (unumber)(number) 6
Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$0) ← (unumber)(number) 2
Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$1) ← (unumber)(number) 3
Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (unumber~) main::$2) ← (unumber)(number) 5
Inlining cast *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (unumber~) main::$3) ← (unumber)(number) 6
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
@ -161,53 +145,37 @@ Inferred type updated to byte in (unumber~) main::$5 ← (byte) 0 * (const byte)
Inferred type updated to byte in (unumber~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Inferred type updated to byte in (unumber~) main::$7 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [0] (byte~) main::$0 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [1] (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [3] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [4] (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [6] (byte~) main::$2 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [7] (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [9] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [10] (byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [12] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [13] (byte*~) main::$12 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [15] (byte~) main::$5 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [16] (byte*~) main::$13 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [18] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [19] (byte*~) main::$14 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [21] (byte~) main::$7 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [22] (byte*~) main::$15 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [2] (byte~) main::$1 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [4] (byte~) main::$2 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [6] (byte~) main::$3 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [8] (byte~) main::$4 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [10] (byte~) main::$5 ← (byte) 0 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [12] (byte~) main::$6 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Constant right-side identified [14] (byte~) main::$7 ← (byte) 1 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$0 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$8 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$1 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$9 = (byte*)points+OFFSET_STRUCT_POINT_Y
Constant (const byte) main::$2 = 1*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$10 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$3 = 1*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$11 = (byte*)points+OFFSET_STRUCT_POINT_Y
Constant (const byte) main::$4 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$12 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$5 = 0*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$13 = (byte*)points+OFFSET_STRUCT_POINT_Y
Constant (const byte) main::$6 = 1*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$14 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte) main::$7 = 1*SIZEOF_STRUCT_POINT
Constant (const byte*) main::$15 = (byte*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Simplifying constant evaluating to zero (byte) 0*(const byte) SIZEOF_STRUCT_POINT in
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero main::$8 in [2] *((const byte*) main::$8 + (const byte) main::$0) ← (byte) 2
Simplifying expression containing zero main::$9 in [5] *((const byte*) main::$9 + (const byte) main::$1) ← (byte) 3
Simplifying expression containing zero main::$12 in [14] *((const byte*) main::SCREEN + (byte) 0) ← *((const byte*) main::$12 + (const byte) main::$4)
Simplifying expression containing zero main::SCREEN in [14] *((const byte*) main::SCREEN + (byte) 0) ← *((const byte*) main::$12)
Simplifying expression containing zero main::$13 in [17] *((const byte*) main::SCREEN + (byte) 1) ← *((const byte*) main::$13 + (const byte) main::$5)
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$0) ← (byte) 2
Simplifying expression containing zero (byte*)points in [1] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X) ← (byte) 2
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [3] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$1) ← (byte) 3
Simplifying expression containing zero (byte*)points in [5] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$2) ← (byte) 5
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_X in [9] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$4)
Simplifying expression containing zero (byte*)points in [9] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X)
Simplifying expression containing zero main::SCREEN in [9] *((const byte*) main::SCREEN + (byte) 0) ← *((byte*)(const struct Point*) points)
Simplifying expression containing zero (byte*)points+OFFSET_STRUCT_POINT_Y in [11] *((const byte*) main::SCREEN + (byte) 1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (const byte) main::$5)
Simplifying expression containing zero (byte*)points in [13] *((const byte*) main::SCREEN + (byte) 3) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (const byte) main::$6)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) main::$0
Eliminating unused constant (const byte) main::$1
@ -215,18 +183,10 @@ Eliminating unused constant (const byte) main::$4
Eliminating unused constant (const byte) main::$5
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
Constant inlined main::$12 = (byte*)(const struct Point*) points
Constant inlined main::$13 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$14 = (byte*)(const struct Point*) points
Constant inlined main::$15 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$10 = (byte*)(const struct Point*) points
Constant inlined main::$11 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$2 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$6 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$3 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$9 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$2 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$7 = (byte) 1*(const byte) SIZEOF_STRUCT_POINT
Constant inlined main::$8 = (byte*)(const struct Point*) points
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *((byte*)points+1*SIZEOF_STRUCT_POINT)
Consolidated array index constant in *((byte*)points+OFFSET_STRUCT_POINT_Y+1*SIZEOF_STRUCT_POINT)

59
src/test/ref/struct-ptr-8.log
View File

@ -2,10 +2,10 @@ Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
Fixing pointer array-indexing *((const struct Point*) points + (byte) main::i1)
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$4).x
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$5).y
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$6).x
Rewriting struct pointer member access *((const struct Point*) points + (byte~) main::$7).y
Replacing struct member reference *((const struct Point*) points + (byte~) main::$4).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$4)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$5).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$6).x with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$6)
Replacing struct member reference *((const struct Point*) points + (byte~) main::$7).y with member unwinding reference *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$7)
Culled Empty Block (label) main::@4
CONTROL FLOW GRAPH SSA
@ -20,12 +20,10 @@ main::@1: scope:[main] from main main::@1
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
(number~) main::$0 ← (number) 2 + (byte) main::i#2
(byte~) main::$4 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((byte*~) main::$8 + (byte~) main::$4) ← (number~) main::$0
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$4) ← (number~) main::$0
(number~) main::$1 ← (number) 3 + (byte) main::i#2
(byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((byte*~) main::$9 + (byte~) main::$5) ← (number~) main::$1
*((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$5) ← (number~) main::$1
(byte) main::i#1 ← (byte) main::i#2 + rangenext(0,1)
(bool~) main::$2 ← (byte) main::i#1 != rangelast(0,1)
if((bool~) main::$2) goto main::@1
@ -38,12 +36,10 @@ main::@3: scope:[main] from main::@2 main::@3
(byte) main::idx#4 ← phi( main::@2/(byte) main::idx#0 main::@3/(byte) main::idx#3 )
(byte) main::i1#2 ← phi( main::@2/(byte) main::i1#0 main::@3/(byte) main::i1#1 )
(byte~) main::$6 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
*((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*~) main::$10 + (byte~) main::$6)
*((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$6)
(byte) main::idx#1 ← ++ (byte) main::idx#4
(byte~) main::$7 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
(byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
*((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*~) main::$11 + (byte~) main::$7)
*((const byte*) main::SCREEN + (byte) main::idx#1) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y + (byte~) main::$7)
(byte) main::idx#2 ← ++ (byte) main::idx#1
*((const byte*) main::SCREEN + (byte) main::idx#2) ← (byte) ' '
(byte) main::idx#3 ← ++ (byte) main::idx#2
@ -74,16 +70,12 @@ SYMBOL TABLE SSA
(void()) main()
(number~) main::$0
(number~) main::$1
(byte*~) main::$10
(byte*~) main::$11
(bool~) main::$2
(bool~) main::$3
(byte~) main::$4
(byte~) main::$5
(byte~) main::$6
(byte~) main::$7
(byte*~) main::$8
(byte*~) main::$9
(label) main::@1
(label) main::@2
(label) main::@3
@ -119,31 +111,22 @@ Finalized unsigned number type (byte) 3
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) main::$0 ← (byte) 2 + (byte) main::i#2
Inferred type updated to byte in (unumber~) main::$1 ← (byte) 3 + (byte) main::i#2
Identified duplicate assignment right side [7] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [20] (byte~) main::$7 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [6] (byte~) main::$5 ← (byte) main::i#2 * (const byte) SIZEOF_STRUCT_POINT
Identified duplicate assignment right side [17] (byte~) main::$7 ← (byte) main::i1#2 * (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) main::$2 [12] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
Simple Condition (bool~) main::$3 [28] if((byte) main::i1#1!=rangelast(0,1)) goto main::@3
Simple Condition (bool~) main::$2 [10] if((byte) main::i#1!=rangelast(0,1)) goto main::@1
Simple Condition (bool~) main::$3 [24] if((byte) main::i1#1!=rangelast(0,1)) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [4] (byte*~) main::$8 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [8] (byte*~) main::$9 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Constant right-side identified [17] (byte*~) main::$10 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_X
Constant right-side identified [21] (byte*~) main::$11 ← (byte*)(const struct Point*) points + (const byte) OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::i#0 = 0
Constant (const byte*) main::$8 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$9 = (byte*)points+OFFSET_STRUCT_POINT_Y
Constant (const byte) main::idx#0 = 0
Constant (const byte) main::i1#0 = 0
Constant (const byte*) main::$10 = (byte*)points+OFFSET_STRUCT_POINT_X
Constant (const byte*) main::$11 = (byte*)points+OFFSET_STRUCT_POINT_Y
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [10] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [12] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
Resolved ranged next value [26] main::i1#1 ← ++ main::i1#2 to ++
Resolved ranged comparison value [28] if(main::i1#1!=rangelast(0,1)) goto main::@3 to (number) 2
Simplifying expression containing zero (byte*)points in
Simplifying expression containing zero (byte*)points in
Resolved ranged next value [8] main::i#1 ← ++ main::i#2 to ++
Resolved ranged comparison value [10] if(main::i#1!=rangelast(0,1)) goto main::@1 to (number) 2
Resolved ranged next value [22] main::i1#1 ← ++ main::i1#2 to ++
Resolved ranged comparison value [24] if(main::i1#1!=rangelast(0,1)) goto main::@3 to (number) 2
Simplifying expression containing zero (byte*)points in [4] *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$4) ← (byte~) main::$0
Simplifying expression containing zero (byte*)points in [15] *((const byte*) main::SCREEN + (byte) main::idx#4) ← *((byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_X + (byte~) main::$6)
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) OFFSET_STRUCT_POINT_X
Successful SSA optimization PassNEliminateUnusedVars
@ -165,13 +148,9 @@ Successful SSA optimization Pass2MultiplyToShiftRewriting
Inlining constant with var siblings (const byte) main::i#0
Inlining constant with var siblings (const byte) main::idx#0
Inlining constant with var siblings (const byte) main::i1#0
Constant inlined main::idx#0 = (byte) 0
Constant inlined main::i#0 = (byte) 0
Constant inlined main::i1#0 = (byte) 0
Constant inlined main::$9 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::$10 = (byte*)(const struct Point*) points
Constant inlined main::$8 = (byte*)(const struct Point*) points
Constant inlined main::$11 = (byte*)(const struct Point*) points+(const byte) OFFSET_STRUCT_POINT_Y
Constant inlined main::idx#0 = (byte) 0
Successful SSA optimization Pass2ConstantInlining
Eliminating unused constant (const byte) SIZEOF_STRUCT_POINT
Successful SSA optimization PassNEliminateUnusedVars