From 8f57e098deca8d42867e45fc1bcb2f8d7e5f76d4 Mon Sep 17 00:00:00 2001 From: Scott Lahteine Date: Sun, 15 Apr 2018 19:02:30 -0500 Subject: [PATCH] Use end-of-line comments in planner.cpp --- Marlin/src/module/planner.cpp | 348 +++++++++++++++++----------------- 1 file changed, 174 insertions(+), 174 deletions(-) diff --git a/Marlin/src/module/planner.cpp b/Marlin/src/module/planner.cpp index 43d01d3dc..5a5ef562e 100644 --- a/Marlin/src/module/planner.cpp +++ b/Marlin/src/module/planner.cpp @@ -406,300 +406,300 @@ void Planner::init() { register const uint8_t* ptab = inv_tab; __asm__ __volatile__( - /* %8:%7:%6 = interval*/ - /* r31:r30: MUST be those registers, and they must point to the inv_tab */ + // %8:%7:%6 = interval + // r31:r30: MUST be those registers, and they must point to the inv_tab - " clr %13" "\n\t" /* %13 = 0 */ + " clr %13" "\n\t" // %13 = 0 - /* Now we must compute */ - /* result = 0xFFFFFF / d */ - /* %8:%7:%6 = interval*/ - /* %16:%15:%14 = nr */ - /* %13 = 0*/ + // Now we must compute + // result = 0xFFFFFF / d + // %8:%7:%6 = interval + // %16:%15:%14 = nr + // %13 = 0 - /* A plain division of 24x24 bits should take 388 cycles to complete. We will */ - /* use Newton-Raphson for the calculation, and will strive to get way less cycles*/ - /* for the same result - Using C division, it takes 500cycles to complete .*/ + // A plain division of 24x24 bits should take 388 cycles to complete. We will + // use Newton-Raphson for the calculation, and will strive to get way less cycles + // for the same result - Using C division, it takes 500cycles to complete . - " clr %3" "\n\t" /* idx = 0 */ + " clr %3" "\n\t" // idx = 0 " mov %14,%6" "\n\t" " mov %15,%7" "\n\t" - " mov %16,%8" "\n\t" /* nr = interval */ - " tst %16" "\n\t" /* nr & 0xFF0000 == 0 ? */ - " brne 2f" "\n\t" /* No, skip this */ + " mov %16,%8" "\n\t" // nr = interval + " tst %16" "\n\t" // nr & 0xFF0000 == 0 ? + " brne 2f" "\n\t" // No, skip this " mov %16,%15" "\n\t" - " mov %15,%14" "\n\t" /* nr <<= 8, %14 not needed */ - " subi %3,-8" "\n\t" /* idx += 8 */ - " tst %16" "\n\t" /* nr & 0xFF0000 == 0 ? */ - " brne 2f" "\n\t" /* No, skip this */ - " mov %16,%15" "\n\t" /* nr <<= 8, %14 not needed */ - " clr %15" "\n\t" /* We clear %14 */ - " subi %3,-8" "\n\t" /* idx += 8 */ + " mov %15,%14" "\n\t" // nr <<= 8, %14 not needed + " subi %3,-8" "\n\t" // idx += 8 + " tst %16" "\n\t" // nr & 0xFF0000 == 0 ? + " brne 2f" "\n\t" // No, skip this + " mov %16,%15" "\n\t" // nr <<= 8, %14 not needed + " clr %15" "\n\t" // We clear %14 + " subi %3,-8" "\n\t" // idx += 8 - /* here %16 != 0 and %16:%15 contains at least 9 MSBits, or both %16:%15 are 0 */ + // here %16 != 0 and %16:%15 contains at least 9 MSBits, or both %16:%15 are 0 "2:" "\n\t" - " cpi %16,0x10" "\n\t" /* (nr & 0xf00000) == 0 ? */ - " brcc 3f" "\n\t" /* No, skip this */ - " swap %15" "\n\t" /* Swap nibbles */ - " swap %16" "\n\t" /* Swap nibbles. Low nibble is 0 */ + " cpi %16,0x10" "\n\t" // (nr & 0xf00000) == 0 ? + " brcc 3f" "\n\t" // No, skip this + " swap %15" "\n\t" // Swap nibbles + " swap %16" "\n\t" // Swap nibbles. Low nibble is 0 " mov %14, %15" "\n\t" - " andi %14,0x0f" "\n\t" /* Isolate low nibble */ - " andi %15,0xf0" "\n\t" /* Keep proper nibble in %15 */ - " or %16, %14" "\n\t" /* %16:%15 <<= 4 */ - " subi %3,-4" "\n\t" /* idx += 4 */ + " andi %14,0x0f" "\n\t" // Isolate low nibble + " andi %15,0xf0" "\n\t" // Keep proper nibble in %15 + " or %16, %14" "\n\t" // %16:%15 <<= 4 + " subi %3,-4" "\n\t" // idx += 4 "3:" "\n\t" - " cpi %16,0x40" "\n\t" /* (nr & 0xc00000) == 0 ? */ - " brcc 4f" "\n\t" /* No, skip this*/ + " cpi %16,0x40" "\n\t" // (nr & 0xc00000) == 0 ? + " brcc 4f" "\n\t" // No, skip this " add %15,%15" "\n\t" " adc %16,%16" "\n\t" " add %15,%15" "\n\t" - " adc %16,%16" "\n\t" /* %16:%15 <<= 2 */ - " subi %3,-2" "\n\t" /* idx += 2 */ + " adc %16,%16" "\n\t" // %16:%15 <<= 2 + " subi %3,-2" "\n\t" // idx += 2 "4:" "\n\t" - " cpi %16,0x80" "\n\t" /* (nr & 0x800000) == 0 ? */ - " brcc 5f" "\n\t" /* No, skip this */ + " cpi %16,0x80" "\n\t" // (nr & 0x800000) == 0 ? + " brcc 5f" "\n\t" // No, skip this " add %15,%15" "\n\t" - " adc %16,%16" "\n\t" /* %16:%15 <<= 1 */ - " inc %3" "\n\t" /* idx += 1 */ + " adc %16,%16" "\n\t" // %16:%15 <<= 1 + " inc %3" "\n\t" // idx += 1 - /* Now %16:%15 contains its MSBit set to 1, or %16:%15 is == 0. We are now absolutely sure*/ - /* we have at least 9 MSBits available to enter the initial estimation table*/ + // Now %16:%15 contains its MSBit set to 1, or %16:%15 is == 0. We are now absolutely sure + // we have at least 9 MSBits available to enter the initial estimation table "5:" "\n\t" " add %15,%15" "\n\t" - " adc %16,%16" "\n\t" /* %16:%15 = tidx = (nr <<= 1), we lose the top MSBit (always set to 1, %16 is the index into the inverse table)*/ - " add r30,%16" "\n\t" /* Only use top 8 bits */ - " adc r31,%13" "\n\t" /* r31:r30 = inv_tab + (tidx) */ - " lpm %14, Z" "\n\t" /* %14 = inv_tab[tidx] */ - " ldi %15, 1" "\n\t" /* %15 = 1 %15:%14 = inv_tab[tidx] + 256 */ + " adc %16,%16" "\n\t" // %16:%15 = tidx = (nr <<= 1), we lose the top MSBit (always set to 1, %16 is the index into the inverse table) + " add r30,%16" "\n\t" // Only use top 8 bits + " adc r31,%13" "\n\t" // r31:r30 = inv_tab + (tidx) + " lpm %14, Z" "\n\t" // %14 = inv_tab[tidx] + " ldi %15, 1" "\n\t" // %15 = 1 %15:%14 = inv_tab[tidx] + 256 - /* We must scale the approximation to the proper place*/ - " clr %16" "\n\t" /* %16 will always be 0 here */ - " subi %3,8" "\n\t" /* idx == 8 ? */ - " breq 6f" "\n\t" /* yes, no need to scale*/ - " brcs 7f" "\n\t" /* If C=1, means idx < 8, result was negative!*/ + // We must scale the approximation to the proper place + " clr %16" "\n\t" // %16 will always be 0 here + " subi %3,8" "\n\t" // idx == 8 ? + " breq 6f" "\n\t" // yes, no need to scale + " brcs 7f" "\n\t" // If C=1, means idx < 8, result was negative! - /* idx > 8, now %3 = idx - 8. We must perform a left shift. idx range:[1-8]*/ - " sbrs %3,0" "\n\t" /* shift by 1bit position?*/ - " rjmp 8f" "\n\t" /* No*/ + // idx > 8, now %3 = idx - 8. We must perform a left shift. idx range:[1-8] + " sbrs %3,0" "\n\t" // shift by 1bit position? + " rjmp 8f" "\n\t" // No " add %14,%14" "\n\t" - " adc %15,%15" "\n\t" /* %15:16 <<= 1*/ + " adc %15,%15" "\n\t" // %15:16 <<= 1 "8:" "\n\t" - " sbrs %3,1" "\n\t" /* shift by 2bit position?*/ - " rjmp 9f" "\n\t" /* No*/ + " sbrs %3,1" "\n\t" // shift by 2bit position? + " rjmp 9f" "\n\t" // No " add %14,%14" "\n\t" " adc %15,%15" "\n\t" " add %14,%14" "\n\t" - " adc %15,%15" "\n\t" /* %15:16 <<= 1*/ + " adc %15,%15" "\n\t" // %15:16 <<= 1 "9:" "\n\t" - " sbrs %3,2" "\n\t" /* shift by 4bits position?*/ - " rjmp 16f" "\n\t" /* No*/ - " swap %15" "\n\t" /* Swap nibbles. lo nibble of %15 will always be 0*/ - " swap %14" "\n\t" /* Swap nibbles*/ + " sbrs %3,2" "\n\t" // shift by 4bits position? + " rjmp 16f" "\n\t" // No + " swap %15" "\n\t" // Swap nibbles. lo nibble of %15 will always be 0 + " swap %14" "\n\t" // Swap nibbles " mov %12,%14" "\n\t" - " andi %12,0x0f" "\n\t" /* isolate low nibble*/ - " andi %14,0xf0" "\n\t" /* and clear it*/ - " or %15,%12" "\n\t" /* %15:%16 <<= 4*/ + " andi %12,0x0f" "\n\t" // isolate low nibble + " andi %14,0xf0" "\n\t" // and clear it + " or %15,%12" "\n\t" // %15:%16 <<= 4 "16:" "\n\t" - " sbrs %3,3" "\n\t" /* shift by 8bits position?*/ - " rjmp 6f" "\n\t" /* No, we are done */ + " sbrs %3,3" "\n\t" // shift by 8bits position? + " rjmp 6f" "\n\t" // No, we are done " mov %16,%15" "\n\t" " mov %15,%14" "\n\t" " clr %14" "\n\t" " jmp 6f" "\n\t" - /* idx < 8, now %3 = idx - 8. Get the count of bits */ + // idx < 8, now %3 = idx - 8. Get the count of bits "7:" "\n\t" - " neg %3" "\n\t" /* %3 = -idx = count of bits to move right. idx range:[1...8]*/ - " sbrs %3,0" "\n\t" /* shift by 1 bit position ?*/ - " rjmp 10f" "\n\t" /* No, skip it*/ - " asr %15" "\n\t" /* (bit7 is always 0 here)*/ + " neg %3" "\n\t" // %3 = -idx = count of bits to move right. idx range:[1...8] + " sbrs %3,0" "\n\t" // shift by 1 bit position ? + " rjmp 10f" "\n\t" // No, skip it + " asr %15" "\n\t" // (bit7 is always 0 here) " ror %14" "\n\t" "10:" "\n\t" - " sbrs %3,1" "\n\t" /* shift by 2 bit position ?*/ - " rjmp 11f" "\n\t" /* No, skip it*/ - " asr %15" "\n\t" /* (bit7 is always 0 here)*/ + " sbrs %3,1" "\n\t" // shift by 2 bit position ? + " rjmp 11f" "\n\t" // No, skip it + " asr %15" "\n\t" // (bit7 is always 0 here) " ror %14" "\n\t" - " asr %15" "\n\t" /* (bit7 is always 0 here)*/ + " asr %15" "\n\t" // (bit7 is always 0 here) " ror %14" "\n\t" "11:" "\n\t" - " sbrs %3,2" "\n\t" /* shift by 4 bit position ?*/ - " rjmp 12f" "\n\t" /* No, skip it*/ - " swap %15" "\n\t" /* Swap nibbles*/ - " andi %14, 0xf0" "\n\t" /* Lose the lowest nibble*/ - " swap %14" "\n\t" /* Swap nibbles. Upper nibble is 0*/ - " or %14,%15" "\n\t" /* Pass nibble from upper byte*/ - " andi %15, 0x0f" "\n\t" /* And get rid of that nibble*/ + " sbrs %3,2" "\n\t" // shift by 4 bit position ? + " rjmp 12f" "\n\t" // No, skip it + " swap %15" "\n\t" // Swap nibbles + " andi %14, 0xf0" "\n\t" // Lose the lowest nibble + " swap %14" "\n\t" // Swap nibbles. Upper nibble is 0 + " or %14,%15" "\n\t" // Pass nibble from upper byte + " andi %15, 0x0f" "\n\t" // And get rid of that nibble "12:" "\n\t" - " sbrs %3,3" "\n\t" /* shift by 8 bit position ?*/ - " rjmp 6f" "\n\t" /* No, skip it*/ + " sbrs %3,3" "\n\t" // shift by 8 bit position ? + " rjmp 6f" "\n\t" // No, skip it " mov %14,%15" "\n\t" " clr %15" "\n\t" - "6:" "\n\t" /* %16:%15:%14 = initial estimation of 0x1000000 / d*/ + "6:" "\n\t" // %16:%15:%14 = initial estimation of 0x1000000 / d - /* Now, we must refine the estimation present on %16:%15:%14 using 1 iteration*/ - /* of Newton-Raphson. As it has a quadratic convergence, 1 iteration is enough*/ - /* to get more than 18bits of precision (the initial table lookup gives 9 bits of*/ - /* precision to start from). 18bits of precision is all what is needed here for result */ + // Now, we must refine the estimation present on %16:%15:%14 using 1 iteration + // of Newton-Raphson. As it has a quadratic convergence, 1 iteration is enough + // to get more than 18bits of precision (the initial table lookup gives 9 bits of + // precision to start from). 18bits of precision is all what is needed here for result - /* %8:%7:%6 = d = interval*/ - /* %16:%15:%14 = x = initial estimation of 0x1000000 / d*/ - /* %13 = 0*/ - /* %3:%2:%1:%0 = working accumulator*/ + // %8:%7:%6 = d = interval + // %16:%15:%14 = x = initial estimation of 0x1000000 / d + // %13 = 0 + // %3:%2:%1:%0 = working accumulator - /* Compute 1<<25 - x*d. Result should never exceed 25 bits and should always be positive*/ + // Compute 1<<25 - x*d. Result should never exceed 25 bits and should always be positive " clr %0" "\n\t" " clr %1" "\n\t" " clr %2" "\n\t" - " ldi %3,2" "\n\t" /* %3:%2:%1:%0 = 0x2000000*/ - " mul %6,%14" "\n\t" /* r1:r0 = LO(d) * LO(x)*/ + " ldi %3,2" "\n\t" // %3:%2:%1:%0 = 0x2000000 + " mul %6,%14" "\n\t" // r1:r0 = LO(d) * LO(x) " sub %0,r0" "\n\t" " sbc %1,r1" "\n\t" " sbc %2,%13" "\n\t" - " sbc %3,%13" "\n\t" /* %3:%2:%1:%0 -= LO(d) * LO(x)*/ - " mul %7,%14" "\n\t" /* r1:r0 = MI(d) * LO(x)*/ + " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * LO(x) + " mul %7,%14" "\n\t" // r1:r0 = MI(d) * LO(x) " sub %1,r0" "\n\t" " sbc %2,r1" "\n\t" - " sbc %3,%13" "\n\t" /* %3:%2:%1:%0 -= MI(d) * LO(x) << 8*/ - " mul %8,%14" "\n\t" /* r1:r0 = HI(d) * LO(x)*/ + " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= MI(d) * LO(x) << 8 + " mul %8,%14" "\n\t" // r1:r0 = HI(d) * LO(x) " sub %2,r0" "\n\t" - " sbc %3,r1" "\n\t" /* %3:%2:%1:%0 -= MIL(d) * LO(x) << 16*/ - " mul %6,%15" "\n\t" /* r1:r0 = LO(d) * MI(x)*/ + " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MIL(d) * LO(x) << 16 + " mul %6,%15" "\n\t" // r1:r0 = LO(d) * MI(x) " sub %1,r0" "\n\t" " sbc %2,r1" "\n\t" - " sbc %3,%13" "\n\t" /* %3:%2:%1:%0 -= LO(d) * MI(x) << 8*/ - " mul %7,%15" "\n\t" /* r1:r0 = MI(d) * MI(x)*/ + " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * MI(x) << 8 + " mul %7,%15" "\n\t" // r1:r0 = MI(d) * MI(x) " sub %2,r0" "\n\t" - " sbc %3,r1" "\n\t" /* %3:%2:%1:%0 -= MI(d) * MI(x) << 16*/ - " mul %8,%15" "\n\t" /* r1:r0 = HI(d) * MI(x)*/ - " sub %3,r0" "\n\t" /* %3:%2:%1:%0 -= MIL(d) * MI(x) << 24*/ - " mul %6,%16" "\n\t" /* r1:r0 = LO(d) * HI(x)*/ + " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MI(d) * MI(x) << 16 + " mul %8,%15" "\n\t" // r1:r0 = HI(d) * MI(x) + " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MIL(d) * MI(x) << 24 + " mul %6,%16" "\n\t" // r1:r0 = LO(d) * HI(x) " sub %2,r0" "\n\t" - " sbc %3,r1" "\n\t" /* %3:%2:%1:%0 -= LO(d) * HI(x) << 16*/ - " mul %7,%16" "\n\t" /* r1:r0 = MI(d) * HI(x)*/ - " sub %3,r0" "\n\t" /* %3:%2:%1:%0 -= MI(d) * HI(x) << 24*/ - /* %3:%2:%1:%0 = (1<<25) - x*d [169]*/ + " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= LO(d) * HI(x) << 16 + " mul %7,%16" "\n\t" // r1:r0 = MI(d) * HI(x) + " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MI(d) * HI(x) << 24 + // %3:%2:%1:%0 = (1<<25) - x*d [169] - /* We need to multiply that result by x, and we are only interested in the top 24bits of that multiply*/ + // We need to multiply that result by x, and we are only interested in the top 24bits of that multiply - /* %16:%15:%14 = x = initial estimation of 0x1000000 / d*/ - /* %3:%2:%1:%0 = (1<<25) - x*d = acc*/ - /* %13 = 0 */ + // %16:%15:%14 = x = initial estimation of 0x1000000 / d + // %3:%2:%1:%0 = (1<<25) - x*d = acc + // %13 = 0 - /* result = %11:%10:%9:%5:%4*/ - " mul %14,%0" "\n\t" /* r1:r0 = LO(x) * LO(acc)*/ + // result = %11:%10:%9:%5:%4 + " mul %14,%0" "\n\t" // r1:r0 = LO(x) * LO(acc) " mov %4,r1" "\n\t" " clr %5" "\n\t" " clr %9" "\n\t" " clr %10" "\n\t" - " clr %11" "\n\t" /* %11:%10:%9:%5:%4 = LO(x) * LO(acc) >> 8*/ - " mul %15,%0" "\n\t" /* r1:r0 = MI(x) * LO(acc)*/ + " clr %11" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * LO(acc) >> 8 + " mul %15,%0" "\n\t" // r1:r0 = MI(x) * LO(acc) " add %4,r0" "\n\t" " adc %5,r1" "\n\t" " adc %9,%13" "\n\t" " adc %10,%13" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * LO(acc) */ - " mul %16,%0" "\n\t" /* r1:r0 = HI(x) * LO(acc)*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * LO(acc) + " mul %16,%0" "\n\t" // r1:r0 = HI(x) * LO(acc) " add %5,r0" "\n\t" " adc %9,r1" "\n\t" " adc %10,%13" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * LO(acc) << 8*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * LO(acc) << 8 - " mul %14,%1" "\n\t" /* r1:r0 = LO(x) * MIL(acc)*/ + " mul %14,%1" "\n\t" // r1:r0 = LO(x) * MIL(acc) " add %4,r0" "\n\t" " adc %5,r1" "\n\t" " adc %9,%13" "\n\t" " adc %10,%13" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 = LO(x) * MIL(acc)*/ - " mul %15,%1" "\n\t" /* r1:r0 = MI(x) * MIL(acc)*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * MIL(acc) + " mul %15,%1" "\n\t" // r1:r0 = MI(x) * MIL(acc) " add %5,r0" "\n\t" " adc %9,r1" "\n\t" " adc %10,%13" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 8*/ - " mul %16,%1" "\n\t" /* r1:r0 = HI(x) * MIL(acc)*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 8 + " mul %16,%1" "\n\t" // r1:r0 = HI(x) * MIL(acc) " add %9,r0" "\n\t" " adc %10,r1" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 16*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIL(acc) << 16 - " mul %14,%2" "\n\t" /* r1:r0 = LO(x) * MIH(acc)*/ + " mul %14,%2" "\n\t" // r1:r0 = LO(x) * MIH(acc) " add %5,r0" "\n\t" " adc %9,r1" "\n\t" " adc %10,%13" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 = LO(x) * MIH(acc) << 8*/ - " mul %15,%2" "\n\t" /* r1:r0 = MI(x) * MIH(acc)*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * MIH(acc) << 8 + " mul %15,%2" "\n\t" // r1:r0 = MI(x) * MIH(acc) " add %9,r0" "\n\t" " adc %10,r1" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 16*/ - " mul %16,%2" "\n\t" /* r1:r0 = HI(x) * MIH(acc)*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 16 + " mul %16,%2" "\n\t" // r1:r0 = HI(x) * MIH(acc) " add %10,r0" "\n\t" - " adc %11,r1" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 24*/ + " adc %11,r1" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * MIH(acc) << 24 - " mul %14,%3" "\n\t" /* r1:r0 = LO(x) * HI(acc)*/ + " mul %14,%3" "\n\t" // r1:r0 = LO(x) * HI(acc) " add %9,r0" "\n\t" " adc %10,r1" "\n\t" - " adc %11,%13" "\n\t" /* %11:%10:%9:%5:%4 = LO(x) * HI(acc) << 16*/ - " mul %15,%3" "\n\t" /* r1:r0 = MI(x) * HI(acc)*/ + " adc %11,%13" "\n\t" // %11:%10:%9:%5:%4 = LO(x) * HI(acc) << 16 + " mul %15,%3" "\n\t" // r1:r0 = MI(x) * HI(acc) " add %10,r0" "\n\t" - " adc %11,r1" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 24*/ - " mul %16,%3" "\n\t" /* r1:r0 = HI(x) * HI(acc)*/ - " add %11,r0" "\n\t" /* %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 32*/ + " adc %11,r1" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 24 + " mul %16,%3" "\n\t" // r1:r0 = HI(x) * HI(acc) + " add %11,r0" "\n\t" // %11:%10:%9:%5:%4 += MI(x) * HI(acc) << 32 - /* At this point, %11:%10:%9 contains the new estimation of x. */ + // At this point, %11:%10:%9 contains the new estimation of x. - /* Finally, we must correct the result. Estimate remainder as*/ - /* (1<<24) - x*d*/ - /* %11:%10:%9 = x*/ - /* %8:%7:%6 = d = interval" "\n\t" /* */ + // Finally, we must correct the result. Estimate remainder as + // (1<<24) - x*d + // %11:%10:%9 = x + // %8:%7:%6 = d = interval" "\n\t" " ldi %3,1" "\n\t" " clr %2" "\n\t" " clr %1" "\n\t" - " clr %0" "\n\t" /* %3:%2:%1:%0 = 0x1000000*/ - " mul %6,%9" "\n\t" /* r1:r0 = LO(d) * LO(x)*/ + " clr %0" "\n\t" // %3:%2:%1:%0 = 0x1000000 + " mul %6,%9" "\n\t" // r1:r0 = LO(d) * LO(x) " sub %0,r0" "\n\t" " sbc %1,r1" "\n\t" " sbc %2,%13" "\n\t" - " sbc %3,%13" "\n\t" /* %3:%2:%1:%0 -= LO(d) * LO(x)*/ - " mul %7,%9" "\n\t" /* r1:r0 = MI(d) * LO(x)*/ + " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * LO(x) + " mul %7,%9" "\n\t" // r1:r0 = MI(d) * LO(x) " sub %1,r0" "\n\t" " sbc %2,r1" "\n\t" - " sbc %3,%13" "\n\t" /* %3:%2:%1:%0 -= MI(d) * LO(x) << 8*/ - " mul %8,%9" "\n\t" /* r1:r0 = HI(d) * LO(x)*/ + " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= MI(d) * LO(x) << 8 + " mul %8,%9" "\n\t" // r1:r0 = HI(d) * LO(x) " sub %2,r0" "\n\t" - " sbc %3,r1" "\n\t" /* %3:%2:%1:%0 -= MIL(d) * LO(x) << 16*/ - " mul %6,%10" "\n\t" /* r1:r0 = LO(d) * MI(x)*/ + " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MIL(d) * LO(x) << 16 + " mul %6,%10" "\n\t" // r1:r0 = LO(d) * MI(x) " sub %1,r0" "\n\t" " sbc %2,r1" "\n\t" - " sbc %3,%13" "\n\t" /* %3:%2:%1:%0 -= LO(d) * MI(x) << 8*/ - " mul %7,%10" "\n\t" /* r1:r0 = MI(d) * MI(x)*/ + " sbc %3,%13" "\n\t" // %3:%2:%1:%0 -= LO(d) * MI(x) << 8 + " mul %7,%10" "\n\t" // r1:r0 = MI(d) * MI(x) " sub %2,r0" "\n\t" - " sbc %3,r1" "\n\t" /* %3:%2:%1:%0 -= MI(d) * MI(x) << 16*/ - " mul %8,%10" "\n\t" /* r1:r0 = HI(d) * MI(x)*/ - " sub %3,r0" "\n\t" /* %3:%2:%1:%0 -= MIL(d) * MI(x) << 24*/ - " mul %6,%11" "\n\t" /* r1:r0 = LO(d) * HI(x)*/ + " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= MI(d) * MI(x) << 16 + " mul %8,%10" "\n\t" // r1:r0 = HI(d) * MI(x) + " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MIL(d) * MI(x) << 24 + " mul %6,%11" "\n\t" // r1:r0 = LO(d) * HI(x) " sub %2,r0" "\n\t" - " sbc %3,r1" "\n\t" /* %3:%2:%1:%0 -= LO(d) * HI(x) << 16*/ - " mul %7,%11" "\n\t" /* r1:r0 = MI(d) * HI(x)*/ - " sub %3,r0" "\n\t" /* %3:%2:%1:%0 -= MI(d) * HI(x) << 24*/ - /* %3:%2:%1:%0 = r = (1<<24) - x*d*/ - /* %8:%7:%6 = d = interval */ + " sbc %3,r1" "\n\t" // %3:%2:%1:%0 -= LO(d) * HI(x) << 16 + " mul %7,%11" "\n\t" // r1:r0 = MI(d) * HI(x) + " sub %3,r0" "\n\t" // %3:%2:%1:%0 -= MI(d) * HI(x) << 24 + // %3:%2:%1:%0 = r = (1<<24) - x*d + // %8:%7:%6 = d = interval - /* Perform the final correction*/ + // Perform the final correction " sub %0,%6" "\n\t" " sbc %1,%7" "\n\t" - " sbc %2,%8" "\n\t" /* r -= d*/ - " brcs 14f" "\n\t" /* if ( r >= d) */ + " sbc %2,%8" "\n\t" // r -= d + " brcs 14f" "\n\t" // if ( r >= d) - /* %11:%10:%9 = x */ + // %11:%10:%9 = x " ldi %3,1" "\n\t" " add %9,%3" "\n\t" " adc %10,%13" "\n\t" - " adc %11,%13" "\n\t" /* x++*/ + " adc %11,%13" "\n\t" // x++ "14:" "\n\t" - /* Estimation is done. %11:%10:%9 = x */ - " clr __zero_reg__" "\n\t" /* Make C runtime happy */ - /* [211 cycles total]*/ + // Estimation is done. %11:%10:%9 = x + " clr __zero_reg__" "\n\t" // Make C runtime happy + // [211 cycles total] : "=r" (r2), "=r" (r3), "=r" (r4),