X-Git-Url: https://git.gir.st/Chiptunes.git/blobdiff_plain/317ff90df2ce14078c3c6e1cba9bd768634c887f..4466dd8b6842dcd98a892ece212799e475c2b1c2:/foo.c?ds=sidebyside diff --git a/foo.c b/foo.c index 6d864b7..ac7d6ad 100644 --- a/foo.c +++ b/foo.c @@ -2,10 +2,6 @@ #include "fakeasm.h" typedef unsigned char u8; -u8 data[] = { - 0x84, 0x9d, 0xb0, 0x69, 0x9d, 0x84, 0x69, 0x58, - 0x75, 0x8c, 0xb0, 0x69, 0x8c, 0x75, 0x69, 0x58 -}; u8 zero; //r16 u8 acc; //r17 u8 i0; //r18 @@ -15,15 +11,24 @@ u8 i3; //r21 u8 n; //r22 u8 s; //r23 u8 _; //r24 -u8 loop; //r25 -u8 t;/*==Ml*/ //r26 (Xlo) -u8 x;/*==Mh*/ //r27 (Xhi) + //r25 +u8 x;/*==Ml*/ //r26 (Xlo) +u8 t;/*==Mh*/ //r27 (Xhi) //r28 //r29 -/*fakestack_l*/ //r30 (Zlo) -/*fakestack_h*/ //r31 (Zhi) +void *Z; //r30 (Zlo) +/*...*/ //r31 (Zhi) #define Mh x //mod3 vars #define Ml t // -"- + +// .section .data +u8 data[] = { + /*.byte*/ 0x84, 0x9d, 0xb0, 0x69, 0x9d, 0x84, 0x69, 0x58, + /*.byte*/ 0x75, 0x8c, 0xb0, 0x69, 0x8c, 0x75, 0x69, 0x58 +}; + +// .section .text + //http://homepage.divms.uiowa.edu/~jones/bcd/mod.shtml void mod3(void) { // mod3(Mh.Ml) -> t @@ -55,130 +60,165 @@ void mod3(void) { RET #undef tmp } -void mul(void) { //don't need overhead of function (inline it) - // i1.i0 * t -> _.x.t +//.macro definitions for mul-tree: +#define always(_bit) //nop; for when a test() is not necessary (see tree) +#define never(_bit) //nop; for when a test() is not necessary (see tree) +#define test(_bit,_jmpto) \ + SBRC (t, _bit) \ + RJMP (_jmpto) +#define shift16 \ + LSR (a2) \ + ROR (a1) +#define shift8 /*top three bits don't need to be corrrect, so save cycles by not carrying*/ \ + LSR (a1) +#define shift0 //nop; last shift is common +#define add_shift16 \ + ADD (a1, i0) \ + ADC (a2, i1, carry) \ + shift16 +#define add_shift8 /*ditto with carrying*/ \ + ADD (a1, i0) \ + shift8 +#define add_shift0 /*last shift is common*/ \ + ADD (a1, i0) +void g(void) { + // g(i, t) -> t + // tempvars: `x` and `_` + #define tmp _ + ANDI (t, 0x07) + MOV (tmp, i2) + ANDI (tmp, 3) + TST (tmp) + CPSE (tmp, zero) + SUBI (t, -8) + #undef tmp + + #define tmp _ + MOV (tmp, t) //NOTE: must move value away from `t`, as that is also hi(X) + tmp = data[tmp];/* + LDI Xhi, hi8(data) + LDI Xlo, lo8(data) + ADD Xlo, tmp ;<-- the offset (formerly `t`) into data[] + ADC Xhi, zero + LD tmp, X */ + MOV (t, tmp) + #undef tmp + #define a1 x #define a2 _ #define a0 t - // start MUL -- 92 cycles :( (unrolled and skipping second bit: 76) CLR (a2) CLR (a1) - #define MUL_ADD_ROR \ - ADD (a1, i0) \ - ADC (a2, i1, carry) \ - MUL_ROR - - #define MUL_ROR \ - LSR (a2) \ - ROR (a1) + /* decision tree multiplication saves cycles and (hopefully) reduces code size + _xxx? + / \ + _xx?0 _xx1? + | | + _x?00 _x?01 + / \ / \ + _?000 _?100 _?001 _?101 + / \ / \ | / \ + _0000 _1000 _0100 _1100 _1001 _0101 _1101 + | | | | | | | + ... ... ... ... ... ... ... + | | | | | | | + B0 58 84 8C 69 75 9D */ + test (0, m____1) + m____0: shift16 + never (1) + m___00: shift16 + test (2, m__100) + m__000: shift16 + test (3, m_1000) + m_0000: shift16 + always (4) + add_shift16 + always (5) + add_shift8 + never (6) + shift8 + always (7) + add_shift0 + RJMP (end_mul) // calc'd 0xb0 - switch(t) { - case 0x58: // 0101 1000 - MUL_ROR - MUL_ROR - MUL_ROR - MUL_ADD_ROR + m_1000: add_shift16 + always (4) + add_shift16 + never (5) + shift8 + always (6) + add_shift8 + never (7) + shift0 + RJMP (end_mul) // calc'd 0x58 - MUL_ADD_ROR - MUL_ROR - MUL_ADD_ROR - MUL_ROR - break; - case 0x69: // 0110 1001 - MUL_ADD_ROR - MUL_ROR - MUL_ROR - MUL_ADD_ROR + m__100: add_shift16 + test (3, m_1100) + m_0100: shift16 + RJMP (upper_8) //'ll calc 0x84 - MUL_ROR - MUL_ADD_ROR - MUL_ADD_ROR - MUL_ROR - break; - case 0x75: // 0111 0101 - MUL_ADD_ROR - MUL_ROR - MUL_ADD_ROR - MUL_ROR + m_1100: add_shift16 + upper_8: /* used twice, so deduplicated */ + never (4) + shift16 + never (5) + shift8 + never (6) + shift8 + always (7) + add_shift0 + RJMP (end_mul) // calc'd 0x8c - MUL_ADD_ROR - MUL_ADD_ROR - MUL_ADD_ROR - MUL_ROR - break; - case 0x84: // 1000 0100 - MUL_ROR - MUL_ROR - MUL_ADD_ROR - MUL_ROR + m____1: add_shift16 + never (1) + m___01: shift16 + test (2, m__101) + m__001: shift16 + always (3) + m_1001: add_shift16 + never (4) + shift16 + always (5) + add_shift8 + always (6) + add_shift8 + never (7) + shift0 + RJMP (end_mul) // calc'd 0x69 - MUL_ROR - MUL_ROR - MUL_ROR - MUL_ADD_ROR - break; - case 0x8c: // 1000 1100 - MUL_ROR - MUL_ROR - MUL_ADD_ROR - MUL_ADD_ROR + m__101: add_shift16 + test (3, m_1101) + m_0101: shift16 + always (4) + add_shift16 + always (5) + add_shift8 + always (6) + add_shift8 + never (7) + shift0 + RJMP (end_mul) // calc'd 0x75 - MUL_ROR - MUL_ROR - MUL_ROR - MUL_ADD_ROR - break; - case 0x9d: // 1001 1101 - MUL_ADD_ROR - MUL_ROR - MUL_ADD_ROR - MUL_ADD_ROR + m_1101: add_shift16 + always (4) + add_shift16 + never (5) + shift8 + never (6) + shift8 + always (7) + add_shift0 + // calc'd 0x9d - MUL_ADD_ROR - MUL_ROR - MUL_ROR - MUL_ADD_ROR - break; - case 0xb0: // 1011 0000 - MUL_ROR - MUL_ROR - MUL_ROR - MUL_ROR - - MUL_ADD_ROR - MUL_ADD_ROR - MUL_ROR - MUL_ADD_ROR - } + end_mul: + LSR (a1) //final shift is a common operation for all - // end MUL + MOV (t, a1) //TODO: use a1 in main() directly #undef a0 #undef a1 #undef a2 - RET -} -void g(void) { - // g(i, t) -> t - // tempvars: `x` and `_` - #define tmp _ - ANDI (t, 0x07) - MOV (tmp, i2) - ANDI (tmp, 3) - TST (tmp) - #undef tmp - BREQ (skip) - SUBI (t, -8) - skip: - t = data[t]; - /*MOV X_hi==x, data_hi - MOV X_lo==t, data_lo - ADD X_lo, t - ADC X_hi, zero - LD t, X */ - RCALL mul(); //stores used value in in x - MOV (t, x) - RET //TODO: replace CALL/RET with IJMP? + RET //TODO: replace CALL/RET with IJMP? (requires undoing goto-mul-hack) }; int main(void) { @@ -334,8 +374,8 @@ int main(void) { putchar(acc<<4); //TODO SUBI (i0, -1) - ADC (i1, zero, !i0) - ADC (i2, zero, !i0&&!i1) - ADC (i3, zero, !i0&&!i1&&!i2) + ADC (i1, zero, !i0) //XXX: must use "sbci i1,-1" in the assembly version + ADC (i2, zero, !i0&&!i1) // sbci i2,-1 + ADC (i3, zero, !i0&&!i1&&!i2) // sbci i3,-1 } }