Является ли это ошибкой оптимизации компилятора или поведение undefined?

У нас есть раздражающая ошибка, которую я не могу объяснить вокруг этого фрагмента кода:

unsigned char bitmap[K_BITMAP_SIZE] = {0} ;
SetBit(bitmap, K_18); // Sets the bit #18 to 1

for(size_t i = 0; i < K_END; ++i)
{
    if(TestBit(bitmap, i)) // true for 18
    {
        size_t i2 = getData(i); // for 18, will return 15
        SetBit(bitmap, i2); // BUG: IS SUPPOSED TO set the bit #15 to 1
    }
}
  • Это происходит на Visual С++ 2010
  • Это происходит как на 32-битных, так и на 64-битных строках
  • Это происходит только в версиях Release (с настройкой "Максимизировать скорость (/O2)"
  • Это происходит не только в версиях Release с параметром "Minimize Size (/O1)"
  • Это происходит на Visual С++ 2008, только если мы __forceinline функцию getData (по умолчанию VС++ 2008 не встроил эту функцию, а VС++ 2010)
  • Это происходит на фрагменте кода, приведенном ниже, вероятно, потому, что массивная вставка внутри цикла
  • Этого не происходит, если мы удалим цикл и непосредственно задаем интересное значение (18)

Информация о бонусе:

1- BenJ прокомментировал, что проблема не появляется на Visual С++ 2012, то есть это может быть ошибкой в ​​компиляторе

2- Если мы добавим cast в unsigned char в функции Test/Set/ResetBit, ошибка также исчезнет.

size_t TestBit(const unsigned char * bits, size_t pos) { return (((bits)[(pos) >> 3]) &   (1 << (unsigned char)((pos) & 7))) ; }
size_t SetBit(unsigned char * bits, size_t pos)        { return (((bits)[(pos) >> 3]) |=  (1 << (unsigned char)((pos) & 7))) ; }
size_t ResetBit(unsigned char * bits, size_t pos)      { return (((bits)[(pos) >> 3]) &= ~(1 << (unsigned char)((pos) & 7))) ; }

Возникает вопрос:

Случается ли эта ошибка, потому что наш код зависит от поведения undefined, или есть какая-то ошибка в компиляторе VС++ 2010?

Следующий источник является самодостаточным и может быть скомпилирован как таковой на вашем любимом компиляторе:

#include <iostream>


const size_t K_UNKNOWN              = (-1) ;
const size_t K_START                = (0) ;
const size_t K_12                   = (K_START + 12) ;
const size_t K_13                   = (K_START + 13) ;
const size_t K_15                   = (K_START + 15) ;
const size_t K_18                   = (K_START + 18) ;
const size_t K_26                   = (K_START + 26) ;
const size_t K_27                   = (K_START + 27) ;
const size_t K_107                  = (K_START + 107) ;
const size_t K_128                  = (K_START + 128) ;
const size_t K_END                  = (K_START + 208) ;
const size_t K_BITMAP_SIZE          = ((K_END/8) + 1) ;


size_t TestBit(const unsigned char * bits, size_t pos) { return (((bits)[(pos) >> 3]) &   (1 << ((pos) & 7))) ; }
size_t SetBit(unsigned char * bits, size_t pos)        { return (((bits)[(pos) >> 3]) |=  (1 << ((pos) & 7))) ; }
size_t ResetBit(unsigned char * bits, size_t pos)      { return (((bits)[(pos) >> 3]) &= ~(1 << ((pos) & 7))) ; }


size_t getData(size_t p_value)
{
    size_t value = K_UNKNOWN;

    switch(p_value)
    {
        case K_13:      value = K_12;        break;
        case K_18:      value = K_15;        break;
        case K_107:     value = K_15;        break;
        case K_27:      value = K_26;        break;
        case K_128:     value = K_12;        break;
        default:        value = p_value;     break;
    }

    return value;
}


void testBug(const unsigned char * p_bitmap)
{
    const size_t byte = p_bitmap[1] ;
    const size_t bit  = 1 << 7 ;
    const size_t value = byte & bit ;

    if(value == 0)
    {
        std::cout << "ERROR : The bit 15 should NOT be 0" << std::endl ;
    }
    else
    {
        std::cout << "Ok : The bit 15 is 1" << std::endl ;
    }
}


int main(int argc, char * argv[])
{
    unsigned char bitmap[K_BITMAP_SIZE] = {0} ;
    SetBit(bitmap, K_18);

    for(size_t i = 0; i < K_END; ++i)
    {
        if(TestBit(bitmap, i))
        {
            size_t i2 = getData(i);
            SetBit(bitmap, i2);
        }
    }

    testBug(bitmap) ;

    return 0;
}

Некоторая справочная информация: Первоначально:

  • Функции Test/Set/ResetBit были макросами.
  • константы определяли
  • индексы были либо long, либо int (в 32-разрядной версии Windows они имеют одинаковый размер)

Если необходимо, я как можно скорее добавлю несколько дополнительных сведений (например, сгенерированный ассемблер для обеих конфигураций, обновить информацию о том, как g++ обрабатывает проблему).

Ответы

Ответ 1

Это ошибка оптимизатора кода. Он включает как getData(), так и SetBit(). Комбинация оказывается фатальной, она теряет отслеживание значения 1 < ((pos) и 7) и всегда производит нуль.

Эта ошибка не возникает на VS2012. Обходной путь заключается в том, чтобы заставить одну из функций не войти в нее. Учитывая код, вы, вероятно, захотите сделать это для getData():

__declspec(noinline)
size_t getData(size_t p_value)
{ 
    // etc..
}

Ответ 2

Добавление 2 Ниже приведена наименьшая возможная часть кода OP. Этот фрагмент приводит к ошибке оптимизатора в VS2010 - зависит от содержимого встроенного расширенного GetData(). Даже если объединить два возвращения в GetData() в один, ошибка "ушла". Кроме того, это не приводит к ошибке, если вы объединяете биты только в первом байте (например, char bitmap[1]; - вам нужны два байта).

Проблема не возникает в VS2012. Это кажется ужасным, потому что MS зафиксировала это, очевидно, в 2012 году, но не в 2010 году. WTF?

BTW:

  • g++ 4.6.2 x64 (-O3) - ok
  • icpc 12.1.0 x64 (-O3) - ok

Проверка ошибок оптимизатора VS2010:

#include <iostream>
const size_t B_5=5, B_9=9;

size_t GetBit(unsigned char * b, size_t p) { return b[p>>3]  & (1 << (p & 7)); }
void   SetBit(unsigned char * b, size_t p) {        b[p>>3] |= (1 << (p & 7)); }

size_t GetData(size_t p) {
   if (p == B_5) return B_9;
   return 0;
}
/* SetBit-invocation will fail (write 0) 
   if inline-expanded in the vicinity of the GetData function, VS2010 */

 int main(int argc, char * argv[])
{
 unsigned char bitmap[2] = { 0, 0 };
 SetBit(bitmap, B_5);

 for(size_t i=0; i<2*8; ++i) {
    if( GetBit(bitmap, i) )         // no difference if temporary variable used,
        SetBit(bitmap, GetData(i)); // the optimizer will drop it anyway
 }

 const size_t byte=bitmap[1], bit=1<<1, value=byte & bit;
 std::cout << (value == 0 ? "ERROR: The bit 9 should NOT be 0" 
                          : "Ok: The bit 9 is 1") << std::endl;
 return 0;
}

После некоторой проверки можно увидеть, что часть инициализации/обнуления не является частью этой конкретной проблемы.

Посмотрел снова после еды. Кажется, это ошибка char/int. Может быть излечен путем изменения функций маски (как было обнаружено OP):

size_t TestBit  (const unsigned char * bits, size_t pos) { 
 return (bits)[pos >> 3] &   (1 << ( char(pos) & 7) ) ; 
}
size_t SetBit   (unsigned char * bits, size_t pos)       { 
 return (bits)[pos >> 3] |=  (1 << ( char(pos) & 7) ) ; 
}
size_t ResetBit (unsigned char * bits, size_t pos)       { 
 return (bits)[pos >> 3] &= ~(1 << ( char(pos) & 7) ) ; 
}

поместив позицию размера t pos в размер char. Это приведет оптимизатора в VS2010 для правильной работы. Может быть, кто-то может прокомментировать.