Extraneous loop produced by PIC compiler from MicroChip

Question

We're using the Lite version of the MicroChip PIC compiler so maybe that's the reason, but this simple one-bit shift is generating a loop where none is necessary. Since the shift count is 1 (a constant), I would expect the compiler to create no loop—an elementary optimization.

Is there a compiler optimization switch that would alleviate the loop? Here is the code for the shift:

    long foo;   // a 32-bit value

// Shift foo one bit. 
// A one-iteration loop is created!

    foo >>= 1;

And here is the compiler-generated code. As you can see, the shift is wrapped with a one-iteration loop.

  07F6    3001     MOVLW 0x1
  07F7    00F2     MOVWF 0x72
  07F8    37F6     ASRF 0x76, F
  07F9    0CF5     RRF 0x75, F
  07FA    0CF4     RRF 0x74, F
  07FB    0CF3     RRF 0x73, F
  07FC    0BF2     DECFSZ 0x72, F

EDIT

Compiler Version: HI-TECH C Compiler for PIC10/12/16 MCUs (Lite Mode) V9.81

Answer 1

Maybe this is caused by the lack of the optimization of the lite version.
You could try,

foo /= 2;

and see if it helps.

Answer 2

I tried various optimisation options, but nothing made the compiler produce sane code. I have had similar experiences with the C18 compiler too. Some of the code it generates it amazingly daft, and I ended up using several types of macros and tricks. In the end, I was able to get it to generate code nearly as good as hand optimised assembler while remaining fairly readable.

This not very nice macro generates the correct assembler for right shifting a long.

long foo;

#define R_SHIFT_LONG(x)     asm("asrf    _" #x "+3, f"); \
                            asm("rrf     _" #x "+2, f"); \
                            asm("rrf     _" #x "+1, f"); \
                            asm("rrf     _" #x "+0, f");

void main(void)
{
    foo=1234;

    R_SHIFT_LONG(foo);
}

Answer 3

Now that I've had a chance to look at your code, it's really not that unreasonable. Depending on the particular model PIC, it could have been done in 4 or 5 instructions, but only in the special case of shifting by one bit. It seems quite reasonable that the first thing the compiler does is write code for the general case where the shift is for N bits. I'd be surprised if it didn't recognize a shift by one bit as a special case with optimizations turned on, but how is this not exactly the kind of thing you expect it to do without optimization?

Again however, if you care about this level of detail you should be writing in assembler. By using a compiler you have deligated away detailed instruction generation. Besides, it's grossly unfair to evaluate any compiler with optimizations turned off.