[bug] cbi optimization error for 8-bit AVRs

Hi everyone!

My problem in sort: I’m getting
	in	r24, 0x18	
	ldi	r25, 0x00	
	andi	r24, 0xEF
	out	0x18, r24	
instead of
	cbi	0x18, 4	
.

I’m trying to write efficient modern C/C++ code for multiple platforms 
including AVR 8 bit controllers.

Unfortunately GCC support for AVR (among other things) is not always 
flawless. And it changes from versions to version (and not always for 
the better).
Since I’m a long time AVR developer I have a lot of compiler versions 
installed (WinAVR 2006-2010, and Atmel Studio 6.2 with GCC 4.8.1), but I 
could test my code with only one (the latest).

I run into some trouble with clearing port bits not translating from C 
into cbi in assembler. It is caused by my bits template, but I do not 
know why. It seems to me like a bug in GCC. Maybe someone here can shed 
some light on the reason, or suggest a fix.

Here is the code:

#include <avr/io.h>
//#include <bits.hpp>

template<typename T>
constexpr unsigned int bits(T idx1)
{
     return (1<<idx1);
}
template <typename T, typename... Rest>
constexpr unsigned int bits(T idx1, Rest... r)
{
     return (1<<idx1) | bits(r...);
}

int main(void)
{
	DDRB = 0x0f;
	for(;;) {
		PORTB |= bits(4);
		PORTB &=~bits(4);

		PORTB |= (1<<4);
		PORTB &=~(1<<4);
	}
}

It’s compiled with avr-gcc (AVR_8_bit_GNU_Toolchain_3.4.4_1229) 4.8.1 
(Atmel Studio 6.2):
avr-gcc -c -mmcu=attiny13 -I. -x c++ -gdwarf-2 -DF_CPU=9600000UL -Os 
-funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums 
-fno-exceptions -Wall -Wundef -fno-strict-aliasing -Winline 
-fno-inline-small-functions  -fno-default-inline -save-temps 
-Wa,-adhlns=./test.lst -ID:/Lib/ -std=gnu++11 -MMD -MP -MF .dep/test.o.d 
test.cpp -o test.o

My older compiler versions do not support -std=gnu++11.  By the way, 
does anyone know when Atmel is coming out with GCC 4.8.3 version for AVR?

----
Here is the preproc output:
template<typename T>
constexpr unsigned int bits(T idx1)
{
     return (1<<idx1);
}
template <typename T, typename... Rest>
constexpr unsigned int bits(T idx1, Rest... r)
{
     return (1<<idx1) | bits(r...);
}

int main(void)
{
  (*(volatile uint8_t *)((0x17) + 0x20)) = 0x0f;
  for(;;) {
   (*(volatile uint8_t *)((0x18) + 0x20)) |= bits(4);
   (*(volatile uint8_t *)((0x18) + 0x20)) &=~bits(4);

   (*(volatile uint8_t *)((0x18) + 0x20)) |= (1<<4);
   (*(volatile uint8_t *)((0x18) + 0x20)) &=~(1<<4);
  }
}

----
Assembly list file (relevant part only):
   19:test.cpp      **** 	for(;;) {
   20:test.cpp      **** 		PORTB |= bits(4);
   26               		.loc 1 20 0 discriminator 1
   27 0004 C49A      		sbi 0x18,4
   28               	.LVL1:
   21:test.cpp      **** 		PORTB &=~bits(4);
   29               		.loc 1 21 0 discriminator 1
   30 0006 88B3      		in r24,0x18
   31 0008 90E0      		ldi r25,0
   32 000a 8F7E      		andi r24,239
   33 000c 88BB      		out 0x18,r24
   22:test.cpp      ****
   23:test.cpp      **** 		PORTB |= (1<<4);
   34               		.loc 1 23 0 discriminator 1
   35 000e C49A      		sbi 0x18,4
   24:test.cpp      **** 		PORTB &=~(1<<4);
   36               		.loc 1 24 0 discriminator 1
   37 0010 C498      		cbi 0x18,4


and the objdump (in case someone likes it better, like me)
	for(;;) {
		PORTB |= bits(4);
   26:	c4 9a       	sbi	0x18, 4	; 24
		PORTB &=~bits(4);
   28:	88 b3       	in	r24, 0x18	; 24
   2a:	90 e0       	ldi	r25, 0x00	; 0	<---WTF?
   2c:	8f 7e       	andi	r24, 0xEF	; 239
   2e:	88 bb       	out	0x18, r24	; 24

		PORTB |= (1<<4);
   30:	c4 9a       	sbi	0x18, 4	; 24
		PORTB &=~(1<<4);
   32:	c4 98       	cbi	0x18, 4	; 24
   34:	f8 cf       	rjmp	.-16     	; 0x26 <main+0x4>


Regards,
Steven