diff --git a/compiler/src/prog8/compiler/target/ICompilationTarget.kt b/compiler/src/prog8/compiler/target/ICompilationTarget.kt
index 708d58fcc..895c02784 100644
--- a/compiler/src/prog8/compiler/target/ICompilationTarget.kt
+++ b/compiler/src/prog8/compiler/target/ICompilationTarget.kt
@@ -119,5 +119,5 @@ internal fun asmGeneratorFor(
     outputDir: Path
 ): IAssemblyGenerator
 {
-    return AsmGen(program, errors, zp, options, outputDir)
+    return AsmGen(program, errors, zp, options, compTarget, outputDir)
 }
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
index 015fad2da..925979bc0 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
@@ -25,6 +25,7 @@ internal class AsmGen(private val program: Program,
                       val errors: ErrorReporter,
                       val zeropage: Zeropage,
                       val options: CompilationOptions,
+                      private val compTarget: ICompilationTarget,
                       private val outputDir: Path): IAssemblyGenerator {
 
     // for expressions and augmented assignments:
@@ -39,7 +40,7 @@ internal class AsmGen(private val program: Program,
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
     private val expressionsAsmGen = ExpressionsAsmGen(program, this)
-    private val assignmentAsmGen = AssignmentAsmGen(program, this, expressionsAsmGen)
+    private val assignmentAsmGen = AssignmentAsmGen(program, this, expressionsAsmGen, compTarget)
     private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this, assignmentAsmGen)
     internal val loopEndLabels = ArrayDeque<String>()
     private val blockLevelVarInits = mutableMapOf<Block, MutableSet<VarDecl>>()
@@ -90,7 +91,7 @@ internal class AsmGen(private val program: Program,
 
     private fun header() {
         val ourName = this.javaClass.name
-        val cpu = when(ICompilationTarget.instance.machine.cpu) {
+        val cpu = when(compTarget.machine.cpu) {
             CpuType.CPU6502 -> "6502"
             CpuType.CPU65c02 -> "65c02"
             else -> "unsupported"
@@ -105,16 +106,16 @@ internal class AsmGen(private val program: Program,
         program.actualLoadAddress = program.definedLoadAddress
         if (program.actualLoadAddress == 0)   // fix load address
             program.actualLoadAddress = if (options.launcher == LauncherType.BASIC)
-                ICompilationTarget.instance.machine.BASIC_LOAD_ADDRESS else ICompilationTarget.instance.machine.RAW_LOAD_ADDRESS
+                compTarget.machine.BASIC_LOAD_ADDRESS else compTarget.machine.RAW_LOAD_ADDRESS
 
         // the global prog8 variables needed
-        val zp = ICompilationTarget.instance.machine.zeropage
+        val zp = compTarget.machine.zeropage
         out("P8ZP_SCRATCH_B1 = ${zp.SCRATCH_B1}")
         out("P8ZP_SCRATCH_REG = ${zp.SCRATCH_REG}")
         out("P8ZP_SCRATCH_W1 = ${zp.SCRATCH_W1}    ; word")
         out("P8ZP_SCRATCH_W2 = ${zp.SCRATCH_W2}    ; word")
-        out("P8ESTACK_LO = ${ICompilationTarget.instance.machine.ESTACK_LO.toHex()}")
-        out("P8ESTACK_HI = ${ICompilationTarget.instance.machine.ESTACK_HI.toHex()}")
+        out("P8ESTACK_LO = ${compTarget.machine.ESTACK_LO.toHex()}")
+        out("P8ESTACK_HI = ${compTarget.machine.ESTACK_HI.toHex()}")
 
         when {
             options.launcher == LauncherType.BASIC -> {
@@ -128,13 +129,13 @@ internal class AsmGen(private val program: Program,
                 out("+\t.word  0")
                 out("_prog8_entrypoint\t; assembly code starts here\n")
                 if(!options.noSysInit)
-                    out("  jsr  ${ICompilationTarget.instance.name}.init_system")
+                    out("  jsr  ${compTarget.name}.init_system")
             }
             options.output == OutputType.PRG -> {
                 out("; ---- program without basic sys call ----")
                 out("* = ${program.actualLoadAddress.toHex()}\n")
                 if(!options.noSysInit)
-                    out("  jsr  ${ICompilationTarget.instance.name}.init_system")
+                    out("  jsr  ${compTarget.name}.init_system")
             }
             options.output == OutputType.RAW -> {
                 out("; ---- raw assembler program ----")
@@ -166,7 +167,7 @@ internal class AsmGen(private val program: Program,
         // the global list of all floating point constants for the whole program
         out("; global float constants")
         for (flt in globalFloatConsts) {
-            val floatFill = ICompilationTarget.instance.machine.getFloat(flt.key).makeFloatFillAsm()
+            val floatFill = compTarget.machine.getFloat(flt.key).makeFloatFillAsm()
             val floatvalue = flt.key
             out("${flt.value}\t.byte  $floatFill  ; float $floatvalue")
         }
@@ -337,7 +338,7 @@ internal class AsmGen(private val program: Program,
                         }
                 val floatFills = array.map {
                     val number = (it as NumericLiteralValue).number
-                    ICompilationTarget.instance.machine.getFloat(number).makeFloatFillAsm()
+                    compTarget.machine.getFloat(number).makeFloatFillAsm()
                 }
                 out(name)
                 for (f in array.zip(floatFills))
@@ -526,7 +527,7 @@ internal class AsmGen(private val program: Program,
         val sourceName = asmVariableName(pointervar)
         val vardecl = pointervar.targetVarDecl(program)!!
         val scopedName = vardecl.makeScopedName(vardecl.name)
-        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if (compTarget.machine.cpu == CpuType.CPU65c02) {
             return if (isZpVar(scopedName)) {
                 // pointervar is already in the zero page, no need to copy
                 out("  lda  ($sourceName)")
@@ -561,7 +562,7 @@ internal class AsmGen(private val program: Program,
     private  fun fixNameSymbols(name: String) = name.replace("<", "prog8_").replace(">", "")     // take care of the autogenerated invalid (anon) label names
 
     internal fun saveRegisterLocal(register: CpuRegister, scope: Subroutine) {
-        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if (compTarget.machine.cpu == CpuType.CPU65c02) {
             // just use the cpu's stack for all registers, shorter code
             when (register) {
                 CpuRegister.A -> out("  pha")
@@ -590,7 +591,7 @@ internal class AsmGen(private val program: Program,
         when (register) {
             CpuRegister.A -> out("  pha")
             CpuRegister.X -> {
-                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phx")
+                if (compTarget.machine.cpu == CpuType.CPU65c02) out("  phx")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  txa |  pha  |  lda  P8ZP_SCRATCH_REG")
@@ -599,7 +600,7 @@ internal class AsmGen(private val program: Program,
                 }
             }
             CpuRegister.Y -> {
-                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  phy")
+                if (compTarget.machine.cpu == CpuType.CPU65c02) out("  phy")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  tya |  pha  |  lda  P8ZP_SCRATCH_REG")
@@ -611,7 +612,7 @@ internal class AsmGen(private val program: Program,
     }
 
     internal fun restoreRegisterLocal(register: CpuRegister) {
-        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if (compTarget.machine.cpu == CpuType.CPU65c02) {
             when (register) {
                 // this just used the stack, for all registers. Shorter code.
                 CpuRegister.A -> out("  pla")
@@ -636,7 +637,7 @@ internal class AsmGen(private val program: Program,
                 out("  pla")
             }
             CpuRegister.X -> {
-                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  plx")
+                if (compTarget.machine.cpu == CpuType.CPU65c02) out("  plx")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  pla |  tax |  lda  P8ZP_SCRATCH_REG")
@@ -645,7 +646,7 @@ internal class AsmGen(private val program: Program,
                 }
             }
             CpuRegister.Y -> {
-                if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) out("  ply")
+                if (compTarget.machine.cpu == CpuType.CPU65c02) out("  ply")
                 else {
                     if(keepA)
                         out("  sta  P8ZP_SCRATCH_REG |  pla |  tay |  lda  P8ZP_SCRATCH_REG")
@@ -705,7 +706,7 @@ internal class AsmGen(private val program: Program,
         val reg = register.toString().toLowerCase()
         val indexnum = expr.indexer.constIndex()
         if(indexnum!=null) {
-            val indexValue = indexnum * ICompilationTarget.instance.memorySize(elementDt) + if(addOneExtra) 1 else 0
+            val indexValue = indexnum * compTarget.memorySize(elementDt) + if(addOneExtra) 1 else 0
             out("  ld$reg  #$indexValue")
             return
         }
@@ -731,7 +732,7 @@ internal class AsmGen(private val program: Program,
                     }
                 }
                 DataType.FLOAT -> {
-                    require(ICompilationTarget.instance.memorySize(DataType.FLOAT)==5)
+                    require(compTarget.memorySize(DataType.FLOAT)==5)
                     out("""
                                 lda  $indexName
                                 asl  a
@@ -758,7 +759,7 @@ internal class AsmGen(private val program: Program,
                     }
                 }
                 DataType.FLOAT -> {
-                    require(ICompilationTarget.instance.memorySize(DataType.FLOAT)==5)
+                    require(compTarget.memorySize(DataType.FLOAT)==5)
                     out("""
                                 lda  $indexName
                                 asl  a
@@ -1328,7 +1329,7 @@ $label              nop""")
         // sign extend signed byte on stack to signed word on stack
         when(valueDt) {
             DataType.UBYTE -> {
-                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(compTarget.machine.cpu == CpuType.CPU65c02)
                     out("  stz  P8ESTACK_HI+1,x")
                 else
                     out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
@@ -1342,7 +1343,7 @@ $label              nop""")
         // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
             DataType.UBYTE -> {
-                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(compTarget.machine.cpu == CpuType.CPU65c02)
                     out("  stz  $asmvar+1")
                 else
                     out("  lda  #0 |  sta  $asmvar+1")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
index f651ed485..b9e0c78f3 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/assignment/AssignmentAsmGen.kt
@@ -8,13 +8,14 @@ import prog8.ast.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.functions.BuiltinFunctions
 import prog8.compiler.functions.builtinFunctionReturnType
-import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.CpuType
+import prog8.compiler.target.ICompilationTarget
 import prog8.compiler.target.c64.codegen.AsmGen
 import prog8.compiler.target.c64.codegen.ExpressionsAsmGen
 
 
-internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen, private val exprAsmgen: ExpressionsAsmGen) {
+internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen,
+                                private val exprAsmgen: ExpressionsAsmGen, private val compTarget: ICompilationTarget) {
 
     private val augmentableAsmGen = AugmentableAssignmentAsmGen(program, this, exprAsmgen, asmgen)
 
@@ -66,7 +67,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 val arrayVarName = asmgen.asmVariableName(value.arrayvar)
                 if (value.indexer.indexNum!=null) {
                     // constant array index value
-                    val indexValue = value.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(elementDt)
+                    val indexValue = value.indexer.constIndex()!! * compTarget.memorySize(elementDt)
                     when (elementDt) {
                         in ByteDatatypes -> {
                             asmgen.out("  lda  $arrayVarName+$indexValue")
@@ -114,7 +115,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             SourceStorageKind.MEMORY -> {
                 fun assignViaExprEval(expression: Expression) {
                     assignExpressionToVariable(expression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, assign.target.scope)
-                    if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if (compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  lda  (P8ZP_SCRATCH_W2)")
                     else
                         asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
@@ -319,7 +320,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
 
                     fun assignViaExprEval(addressExpression: Expression) {
                         asmgen.assignExpressionToVariable(addressExpression, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
-                        if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        if (compTarget.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("  lda  (P8ZP_SCRATCH_W2)")
                         else
                             asmgen.out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
@@ -473,7 +474,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                     }
                     DataType.UWORD, DataType.WORD -> {
-                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(compTarget.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -496,7 +497,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                     }
                     DataType.UWORD -> {
-                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(compTarget.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -592,7 +593,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
                     }
                     DataType.UWORD, DataType.WORD -> {
-                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(compTarget.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -620,7 +621,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                         asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName")
                     }
                     DataType.UWORD -> {
-                        if(ICompilationTarget.instance.machine.cpu==CpuType.CPU65c02)
+                        if(compTarget.machine.cpu==CpuType.CPU65c02)
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  stz  $targetAsmVarName+1")
                         else
                             asmgen.out("  st${regs.toString().toLowerCase()}  $targetAsmVarName |  lda  #0  |  sta  $targetAsmVarName+1")
@@ -762,7 +763,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.ARRAY -> {
                 if(target.constArrayIndexValue!=null) {
-                    val scaledIdx = target.constArrayIndexValue!! * ICompilationTarget.instance.memorySize(target.datatype)
+                    val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype)
                     when(target.datatype) {
                         in ByteDatatypes -> {
                             asmgen.out(" inx | lda  P8ESTACK_LO,x  | sta  ${target.asmVarname}+$scaledIdx")
@@ -968,7 +969,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             TargetStorageKind.ARRAY -> {
                 target.array!!
                 if(target.constArrayIndexValue!=null) {
-                    val scaledIdx = target.constArrayIndexValue!! * ICompilationTarget.instance.memorySize(target.datatype)
+                    val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype)
                     when(target.datatype) {
                         in ByteDatatypes -> {
                             asmgen.out(" lda  $sourceName  | sta  ${target.asmVarname}+$scaledIdx")
@@ -1191,7 +1192,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.ARRAY -> {
                 if (target.constArrayIndexValue!=null) {
-                    val scaledIdx = target.constArrayIndexValue!! * ICompilationTarget.instance.memorySize(target.datatype)
+                    val scaledIdx = target.constArrayIndexValue!! * compTarget.memorySize(target.datatype)
                     asmgen.out(" lda  $sourceName  | sta  ${target.asmVarname}+$scaledIdx")
                 }
                 else {
@@ -1295,7 +1296,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
         when(wordtarget.kind) {
             TargetStorageKind.VARIABLE -> {
                 asmgen.out("  lda  $sourceName |  sta  ${wordtarget.asmVarname}")
-                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(compTarget.machine.cpu == CpuType.CPU65c02)
                     asmgen.out("  stz  ${wordtarget.asmVarname}+1")
                 else
                     asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
@@ -1304,7 +1305,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 if (wordtarget.constArrayIndexValue!=null) {
                     val scaledIdx = wordtarget.constArrayIndexValue!! * 2
                     asmgen.out("  lda  $sourceName  | sta  ${wordtarget.asmVarname}+$scaledIdx")
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  ${wordtarget.asmVarname}+$scaledIdx+1")
                     else
                         asmgen.out("  lda  #0  | sta  ${wordtarget.asmVarname}+$scaledIdx+1")
@@ -1329,7 +1330,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             }
             TargetStorageKind.STACK -> {
                 asmgen.out("  lda  $sourceName |  sta  P8ESTACK_LO,x")
-                if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                if(compTarget.machine.cpu == CpuType.CPU65c02)
                     asmgen.out("  stz  P8ESTACK_HI,x |  dex")
                 else
                     asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
@@ -1571,7 +1572,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     private fun assignConstantWord(target: AsmAssignTarget, word: Int) {
-        if(word==0 && ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if(word==0 && compTarget.machine.cpu == CpuType.CPU65c02) {
             // optimize setting zero value for this processor
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
@@ -1666,7 +1667,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
     }
 
     private fun assignConstantByte(target: AsmAssignTarget, byte: Short) {
-        if(byte==0.toShort() && ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+        if(byte==0.toShort() && compTarget.machine.cpu == CpuType.CPU65c02) {
             // optimize setting zero value for this cpu
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
@@ -1736,7 +1737,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                 in Cx16VirtualRegisters -> {
                     asmgen.out("  lda  #${byte.toHex()} |  sta  cx16.${target.register.toString().toLowerCase()}")
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  cx16.${target.register.toString().toLowerCase()}+1\n")
                     else
                         asmgen.out("  lda  #0 |  sta  cx16.${target.register.toString().toLowerCase()}+1\n")
@@ -1757,7 +1758,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             // optimized case for float zero
             when(target.kind) {
                 TargetStorageKind.VARIABLE -> {
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("""
                             stz  ${target.asmVarname}
                             stz  ${target.asmVarname}+1
@@ -1777,8 +1778,8 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
                 TargetStorageKind.ARRAY -> {
                     if (target.array!!.indexer.indexNum!=null) {
-                        val indexValue = target.array.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(DataType.FLOAT)
-                        if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                        val indexValue = target.array.indexer.constIndex()!! * compTarget.memorySize(DataType.FLOAT)
+                        if(compTarget.machine.cpu == CpuType.CPU65c02)
                             asmgen.out("""
                                 stz  ${target.asmVarname}+$indexValue
                                 stz  ${target.asmVarname}+$indexValue+1
@@ -1842,7 +1843,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.ARRAY -> {
                     val arrayVarName = target.asmVarname
                     if (target.array!!.indexer.indexNum!=null) {
-                        val indexValue = target.array.indexer.constIndex()!! * ICompilationTarget.instance.memorySize(DataType.FLOAT)
+                        val indexValue = target.array.indexer.constIndex()!! * compTarget.memorySize(DataType.FLOAT)
                         asmgen.out("""
                             lda  $constFloat
                             sta  $arrayVarName+$indexValue
@@ -1975,7 +1976,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             when(wordtarget.kind) {
                 TargetStorageKind.VARIABLE -> {
                     asmgen.out("  lda  ${address.toHex()} |  sta  ${wordtarget.asmVarname}")
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  ${wordtarget.asmVarname}+1")
                     else
                         asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
@@ -1991,7 +1992,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 }
                 TargetStorageKind.STACK -> {
                     asmgen.out("  lda  ${address.toHex()} |  sta  P8ESTACK_LO,x")
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  P8ESTACK_HI,x |  dex")
                     else
                         asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
@@ -2003,7 +2004,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.VARIABLE -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
                     asmgen.out(" sta  ${wordtarget.asmVarname}")
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  ${wordtarget.asmVarname}+1")
                     else
                         asmgen.out("  lda  #0 |  sta  ${wordtarget.asmVarname}+1")
@@ -2023,7 +2024,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                 TargetStorageKind.STACK -> {
                     asmgen.loadByteFromPointerIntoA(identifier)
                     asmgen.out("  sta  P8ESTACK_LO,x")
-                    if(ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if(compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  stz  P8ESTACK_HI,x |  dex")
                     else
                         asmgen.out("  lda  #0 |  sta  P8ESTACK_HI,x |  dex")
@@ -2041,7 +2042,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             when(addressExpr) {
                 is NumericLiteralValue, is IdentifierReference -> {
                     assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
-                    if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if (compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  sta  (P8ZP_SCRATCH_W2)")
                     else
                         asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
@@ -2051,7 +2052,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     asmgen.out("  pha")
                     assignExpressionToVariable(addressExpr, asmgen.asmVariableName("P8ZP_SCRATCH_W2"), DataType.UWORD, null)
                     asmgen.out("  pla")
-                    if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02)
+                    if (compTarget.machine.cpu == CpuType.CPU65c02)
                         asmgen.out("  sta  (P8ZP_SCRATCH_W2)")
                     else
                         asmgen.out("  ldy  #0 |  sta  (P8ZP_SCRATCH_W2),y")
@@ -2063,7 +2064,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
             val sourceName = asmgen.asmVariableName(pointervar)
             val vardecl = pointervar.targetVarDecl(program)!!
             val scopedName = vardecl.makeScopedName(vardecl.name)
-            if (ICompilationTarget.instance.machine.cpu == CpuType.CPU65c02) {
+            if (compTarget.machine.cpu == CpuType.CPU65c02) {
                 if (asmgen.isZpVar(scopedName)) {
                     // pointervar is already in the zero page, no need to copy
                     asmgen.out("  sta  ($sourceName)")