Я пытался решить проблему, с которой столкнулся при обновлении с Clang 14: кажется, что компилятор объявляет, что указатель выходит за пределы области видимости, что приводит к освобождению/перезаписи исходных данных.
#include <cstdio>
#include <cstdint>
struct GenericInterface
{
uint8_t size;
} __attribute__((packed));
struct SpecificInterface
{
uint8_t size;
uint8_t setting;
} __attribute__((packed));
int main()
{
uint8_t setting = 5;
uint8_t size = (uint8_t)sizeof(SpecificInterface);
SpecificInterface specific { size, setting };
GenericInterface* generic = (GenericInterface*)&specific;
GenericInterface* genericEnd = (GenericInterface*)((uint8_t*)generic + size);
printf("Starts off %u\n", generic->size);
while (generic < genericEnd)
{
printf("Checking %u\n", generic->size);
if (generic->size == size)
break;
generic = (GenericInterface*)((uint8_t*)generic + generic->size);
}
printf("Done\n");
return 0;
}
В этом сценарии у меня есть универсальная упакованная структура, которая содержит только переменную размера, и, возможно, множество различных структур, которые также имеют переменную размера в качестве первой переменной. Цель этого состоит в том, чтобы эти другие структуры (например, SpecificInterface) можно было привести к GenericInterface с целью итерации по нескольким структурам, которые упакованы вместе в памяти.
В этом конкретном примере цикл while никогда не должен зацикливаться и должен мгновенно прерываться, однако я заметил, что при компиляции с Clang 15+ с флагом -O3 он застревает в бесконечном цикле. В некоторых версиях это не бесконечный цикл, но напечатанное значение кажется поврежденным. Если вы сделаете переменную generic изменчивой, она сработает. Если вы используете Clang 14, он работает нормально, не зацикливается. Если вы используете Clang 15+ без тега -O3, все работает нормально. Если вы используете gcc, все в порядке. Если убрать петлю, то все в порядке. Если вы измените некоторые строки, например удалите строку generic = (GenericInterface*)((uint8_t*)generic + generic->size);, ничего страшного.
Кажется, здесь может возникнуть проблема с оптимизацией, которая появилась в clang 15? Делаю ли я что-то незаконное и страдаю ли от последствий этого? Я знаю, что есть менее проблемные способы сделать это, но мне просто интересно знать, что здесь происходит, а не искать альтернативные способы сделать это.
Спасибо!
🤔 А знаете ли вы, что...
C++ используется для создания компиляторов, интерпретаторов и других инструментов разработки.
Вы определенно нарушаете правило строгого псевдонимов, вы даже можете решить проблему, добавив -fno-strict-aliasing к флагам компилятора, но производительность снизится, и это все равно UB, вам нужно использовать какой-то тип объединения, чтобы сообщить компилятору, что он должен ожидать псевдонимов любого этих типов.
#include <cstdio>
#include <cstdint>
struct GenericInterface
{
uint8_t size;
} __attribute__((packed));
struct SpecificInterface
{
uint8_t size;
uint8_t setting;
} __attribute__((packed));
int main()
{
struct alias_union{
union {GenericInterface g; SpecificInterface s; };
};
uint8_t setting = 5;
uint8_t size = (uint8_t)sizeof(SpecificInterface);
SpecificInterface specific { size, setting };
alias_union* generic = (alias_union*)&specific;
alias_union* genericEnd = (alias_union*)((uint8_t*)generic + size);
printf("Starts off %u\n", generic->g.size);
while (generic < genericEnd)
{
printf("Checking %u\n", generic->g.size);
if (generic->g.size == size)
break;
generic = (alias_union*)((uint8_t*)generic + generic->g.size);
}
printf("Done\n");
return 0;
}
Я не совсем уверен, что это на 100% определенное поведение, но компилятору сложнее игнорировать возможность псевдонимов, и я бы рекомендовал вам использовать обобщенное программирование вместо этого.