Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2024-07-30 01:29:08 +00:00
Code Issues Projects Releases Wiki Activity

more bitshift asm stubs (actual functions still to be done)

Browse Source
This commit is contained in:
Irmen de Jong 2019-08-23 23:06:36 +02:00
parent 1d178080a3
commit 9edc92ec29
4 changed files with 157 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
compiler/res/prog8lib/prog8lib.asm
View File

@ -1672,37 +1672,90 @@ _loop_hi sty c64.SCRATCH_ZPREG
rts rts
.pend .pend
ror2_mem_b .proc ror2_mem_ub .proc
; -- in-place 8-bit ror of byte at memory location on stack ; -- in-place 8-bit ror of byte at memory location on stack
inx inx
lda c64.ESTACK_LO,x lda c64.ESTACK_LO,x
sta _mod1+1 sta c64.SCRATCH_ZPWORD1
sta _mod2+1
lda c64.ESTACK_HI,x lda c64.ESTACK_HI,x
sta _mod1+2 sta c64.SCRATCH_ZPWORD1+1
sta _mod2+2 ldy #0
_mod1 lda $ffff ; modified lda (c64.SCRATCH_ZPWORD1),y
lsr a lsr a
bcc _mod2 bcc +
ora #$80 ora #$80
_mod2 sta $ffff ; modified + sta (c64.SCRATCH_ZPWORD1),y
rts rts
.pend .pend
rol2_mem_b .proc rol2_mem_ub .proc
; -- in-place 8-bit rol of byte at memory location on stack ; -- in-place 8-bit rol of byte at memory location on stack
;" lda ${number.toHex()} | cmp #\$80 | rol a | sta ${number.toHex()}" ;" lda ${number.toHex()} | cmp #\$80 | rol a | sta ${number.toHex()}"
inx inx
lda c64.ESTACK_LO,x lda c64.ESTACK_LO,x
sta _mod1+1 sta c64.SCRATCH_ZPWORD1
sta _mod2+1
lda c64.ESTACK_HI,x lda c64.ESTACK_HI,x
sta _mod1+2 sta c64.SCRATCH_ZPWORD1+1
sta _mod2+2 ldy #0
_mod1 lda $ffff ; modified lda (c64.SCRATCH_ZPWORD1),y
cmp #$80 cmp #$80
rol a rol a
_mod2 sta $ffff ; modified sta (c64.SCRATCH_ZPWORD1),y
rts rts
.pend .pend
lsl_array_b .proc
.warn "lsl_array_b" ; TODO
.pend
lsl_array_w .proc
.warn "lsl_array_w" ; TODO
.pend
lsr_array_ub .proc
.warn "lsr_array_ub" ; TODO
.pend
lsr_array_b .proc
.warn "lsr_array_b" ; TODO
.pend
lsr_array_uw .proc
.warn "lsl_array_uw" ; TODO
.pend
lsr_array_w .proc
.warn "lsr_array_w" ; TODO
.pend
rol_array_ub .proc
.warn "rol_array_ub" ; TODO
.pend
rol_array_uw .proc
.warn "rol_array_uw" ; TODO
.pend
rol2_array_ub .proc
.warn "rol2_array_ub" ; TODO
.pend
rol2_array_uw .proc
.warn "rol2_array_uw" ; TODO
.pend
ror_array_ub .proc
.warn "ror_array_ub" ; TODO
.pend
ror_array_uw .proc
.warn "ror_array_uw" ; TODO
.pend
ror2_array_ub .proc
.warn "ror2_array_ub" ; TODO
.pend
ror2_array_uw .proc
.warn "ror2_array_uw" ; TODO
.pend

91
compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
View File

@ -152,13 +152,21 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
""") """)
} }
} }
is ArrayIndexedExpression -> TODO("lsl byte array $what") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.lsl_array_b")
}
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
} }
} }
in WordDatatypes -> { in WordDatatypes -> {
when (what) { when (what) {
is ArrayIndexedExpression -> TODO("lsl sbyte $what") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.lsl_array_w")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" asl $variable | rol $variable+1") asmgen.out(" asl $variable | rol $variable+1")
@ -200,13 +208,21 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
""") """)
} }
} }
is ArrayIndexedExpression -> TODO("lsr byte array $what") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.lsr_array_ub")
}
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
} }
} }
DataType.BYTE -> { DataType.BYTE -> {
when (what) { when (what) {
is ArrayIndexedExpression -> TODO("lsr sbyte $what") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.lsr_array_b")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" lda $variable | asl a | ror $variable") asmgen.out(" lda $variable | asl a | ror $variable")
@ -216,7 +232,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
DataType.UWORD -> { DataType.UWORD -> {
when (what) { when (what) {
is ArrayIndexedExpression -> TODO("lsr uword $what") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.lsr_array_uw")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" lsr $variable+1 | ror $variable") asmgen.out(" lsr $variable+1 | ror $variable")
@ -226,7 +246,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
DataType.WORD -> { DataType.WORD -> {
when (what) { when (what) {
is ArrayIndexedExpression -> TODO("lsr sword $what") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.lsr_array_w")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" lda $variable+1 | asl a | ror $variable+1 | ror $variable") asmgen.out(" lda $variable+1 | asl a | ror $variable+1 | ror $variable")
@ -244,7 +268,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
when (dt.typeOrElse(DataType.STRUCT)) { when (dt.typeOrElse(DataType.STRUCT)) {
DataType.UBYTE -> { DataType.UBYTE -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("rol ubyte array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.rol_array_ub")
}
is DirectMemoryRead -> { is DirectMemoryRead -> {
if (what.addressExpression is NumericLiteralValue) { if (what.addressExpression is NumericLiteralValue) {
val number = (what.addressExpression as NumericLiteralValue).number val number = (what.addressExpression as NumericLiteralValue).number
@ -277,7 +305,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
DataType.UWORD -> { DataType.UWORD -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("rol uword array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.rol_array_uw")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" rol $variable | rol $variable+1") asmgen.out(" rol $variable | rol $variable+1")
@ -295,14 +327,18 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
when (dt.typeOrElse(DataType.STRUCT)) { when (dt.typeOrElse(DataType.STRUCT)) {
DataType.UBYTE -> { DataType.UBYTE -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("rol2 ubyte array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.rol2_array_ub")
}
is DirectMemoryRead -> { is DirectMemoryRead -> {
if (what.addressExpression is NumericLiteralValue) { if (what.addressExpression is NumericLiteralValue) {
val number = (what.addressExpression as NumericLiteralValue).number val number = (what.addressExpression as NumericLiteralValue).number
asmgen.out(" lda ${number.toHex()} | cmp #\$80 | rol a | sta ${number.toHex()}") asmgen.out(" lda ${number.toHex()} | cmp #\$80 | rol a | sta ${number.toHex()}")
} else { } else {
asmgen.translateExpression(what.addressExpression) asmgen.translateExpression(what.addressExpression)
asmgen.out(" jsr prog8_lib.rol2_mem_b") asmgen.out(" jsr prog8_lib.rol2_mem_ub")
} }
} }
is RegisterExpr -> { is RegisterExpr -> {
@ -321,7 +357,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
DataType.UWORD -> { DataType.UWORD -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("rol2 uword array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.rol2_array_uw")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" asl $variable | rol $variable+1 | bcc + | inc $variable |+ ") asmgen.out(" asl $variable | rol $variable+1 | bcc + | inc $variable |+ ")
@ -339,7 +379,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
when (dt.typeOrElse(DataType.STRUCT)) { when (dt.typeOrElse(DataType.STRUCT)) {
DataType.UBYTE -> { DataType.UBYTE -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("ror ubyte array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.ror_array_ub")
}
is DirectMemoryRead -> { is DirectMemoryRead -> {
if (what.addressExpression is NumericLiteralValue) { if (what.addressExpression is NumericLiteralValue) {
val number = (what.addressExpression as NumericLiteralValue).number val number = (what.addressExpression as NumericLiteralValue).number
@ -371,7 +415,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
} }
DataType.UWORD -> { DataType.UWORD -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("ror uword array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.ror_array_uw")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" ror $variable+1 | ror $variable") asmgen.out(" ror $variable+1 | ror $variable")
@ -389,14 +437,18 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
when (dt.typeOrElse(DataType.STRUCT)) { when (dt.typeOrElse(DataType.STRUCT)) {
DataType.UBYTE -> { DataType.UBYTE -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("ror2 ubyte array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.ror2_array_ub")
}
is DirectMemoryRead -> { is DirectMemoryRead -> {
if (what.addressExpression is NumericLiteralValue) { if (what.addressExpression is NumericLiteralValue) {
val number = (what.addressExpression as NumericLiteralValue).number val number = (what.addressExpression as NumericLiteralValue).number
asmgen.out(" lda ${number.toHex()} | lsr a | bcc + | ora #\$80 |+ | sta ${number.toHex()}") asmgen.out(" lda ${number.toHex()} | lsr a | bcc + | ora #\$80 |+ | sta ${number.toHex()}")
} else { } else {
asmgen.translateExpression(what.addressExpression) asmgen.translateExpression(what.addressExpression)
asmgen.out(" jsr prog8_lib.ror2_mem_b") asmgen.out(" jsr prog8_lib.ror2_mem_ub")
} }
} }
is RegisterExpr -> { is RegisterExpr -> {
@ -411,10 +463,15 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
asmgen.out(" lda $variable | lsr a | bcc + | ora #\$80 |+ | sta $variable") asmgen.out(" lda $variable | lsr a | bcc + | ora #\$80 |+ | sta $variable")
} }
else -> throw AssemblyError("weird type") else -> throw AssemblyError("weird type")
} } }
}
DataType.UWORD -> { DataType.UWORD -> {
when(what) { when(what) {
is ArrayIndexedExpression -> TODO("ror2 uword array") is ArrayIndexedExpression -> {
asmgen.translateExpression(what.identifier)
asmgen.translateExpression(what.arrayspec.index)
asmgen.out(" jsr prog8_lib.ror2_array_uw")
}
is IdentifierReference -> { is IdentifierReference -> {
val variable = asmgen.asmIdentifierName(what) val variable = asmgen.asmIdentifierName(what)
asmgen.out(" lsr $variable+1 | ror $variable | bcc + | lda $variable+1 | ora #\$80 | sta $variable+1 |+ ") asmgen.out(" lsr $variable+1 | ror $variable | bcc + | lda $variable+1 | ora #\$80 | sta $variable+1 |+ ")

6
compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
View File

@ -164,10 +164,12 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
DataType.UBYTE, DataType.BYTE -> { DataType.UBYTE, DataType.BYTE -> {
asmgen.out(" lda $varname | sta ${MachineDefinition.ESTACK_LO_HEX},x | dex") asmgen.out(" lda $varname | sta ${MachineDefinition.ESTACK_LO_HEX},x | dex")
} }
DataType.UWORD, DataType.WORD, in ArrayDatatypes, in StringDatatypes -> { DataType.UWORD, DataType.WORD -> {
// (for arrays and strings, push their address)
asmgen.out(" lda $varname | sta ${MachineDefinition.ESTACK_LO_HEX},x | lda $varname+1 | sta ${MachineDefinition.ESTACK_HI_HEX},x | dex") asmgen.out(" lda $varname | sta ${MachineDefinition.ESTACK_LO_HEX},x | lda $varname+1 | sta ${MachineDefinition.ESTACK_HI_HEX},x | dex")
} }
in ArrayDatatypes, in StringDatatypes -> {
asmgen.out(" lda #<$varname | sta ${MachineDefinition.ESTACK_LO_HEX},x | lda #>$varname | sta ${MachineDefinition.ESTACK_HI_HEX},x | dex")
}
DataType.FLOAT -> { DataType.FLOAT -> {
asmgen.out(" lda #<$varname | ldy #>$varname| jsr c64flt.push_float") asmgen.out(" lda #<$varname | ldy #>$varname| jsr c64flt.push_float")
} }

11
examples/arithmetic/bitshift.p8
View File

@ -12,7 +12,9 @@ main {
&ubyte membyte=9999 &ubyte membyte=9999
&uword memword=9999 &uword memword=9999
ubyte[10] ubarray ubyte[10] ubarray
uword[10] uwarray
byte[10] bbarray byte[10] bbarray
word[10] wwarray
sub start() { sub start() {
; lsr(A) ; lsr(A)
@ -61,6 +63,15 @@ main {
lsr(bbarray[1]) lsr(bbarray[1])
lsl(bbarray[1]) lsl(bbarray[1])
lsr(uwarray[1])
lsl(uwarray[1])
ror(uwarray[1])
rol(uwarray[1])
ror2(uwarray[1])
rol2(uwarray[1])
lsr(wwarray[1])
lsl(wwarray[1])
bb /= 2 bb /= 2
bb >>= 1 bb >>= 1