Почему GCC и Clang не делают эту оптимизацию псевдонимов?

Если вы удалите B::x, то B будет соответствовать требованиям 9p7 для класса стандартного макета, и доступ станет совершенно четко определенным, поскольку эти два типа совместимы по макету, 9.2 p17, и оба члена имеют один и тот же тип.

Класс стандартной компоновки — это класс, который:

• не имеет нестатических элементов данных типа класса нестандартного макета (или массива таких типов) или ссылки,
• не имеет виртуальных функций (10.3) и виртуальных базовых классов (10.1),
• имеет одинаковый контроль доступа (раздел 11) для всех нестатических элементов данных,
• не имеет базовых классов нестандартной компоновки,
• либо не имеет нестатических элементов данных в самом производном классе и не более одного базового класса с нестатическими элементами данных, либо не имеет базовых классов с нестатическими элементами данных, и
• не имеет базовых классов того же типа, что и первый нестатический член данных.

Два типа структур стандартного макета совместимы с макетом, если они имеют одинаковое количество нестатических элементов данных, а соответствующие нестатические элементы данных (в порядке объявления) имеют типы, совместимые с макетом.

Неопределенное поведение включает случаи, когда оно работает, даже если не должно.

Согласно стандартному использованию этого объединения позволяет получить доступ к полям типа и размера либо заголовка, либо членов данных:

union Packet {
   struct Header {
   short type;
   short size;  
   } header;
   struct Data {
   short type;
   short size;  
   unsigned char data[MAX_DATA_SIZE];
   } data;
}

Это строго ограничено объединениями, но многие компиляторы поддерживают это как своего рода расширение, при условии, что «неполный» тип будет заканчиваться массивом неопределенного размера. Если вы удалите дополнительный статический не-член из дочернего класса, он действительно станет тривиальным и совместимым с макетом, что позволяет использовать псевдонимы?

struct A {
  int a;
};

struct B  {
  int a;
  //int x;
};

A a;

int g(B *b) {
   a.a = 10;
   b->a++;
   return a.a;
}

Тем не менее, по-прежнему выполняет оптимизацию псевдонимов. В вашем случае с таким же количеством нестатических членов предполагается, что наиболее производный класс будет таким же, как базовый класс. Давайте инвертируем порядок:

#include <vector>
#include <iostream>

struct A {
  int a;
};

struct B : A  {
  int x;
};

B a;

int g(A *b) {
   a.a = 10;
   b->a++;
   return a.a;
}

int main()
{
    std::cout << g((A*)&a);
}

Это возвращает 11, как и ожидалось, поскольку B явно также является A, в отличие от исходной попытки. Давай играть дальше

struct A {
  int a;
};

struct B : A {
    int  foo() { return a;}
};

Не вызовет оптимизацию алиасинга, если только foo() не является виртуальным. Добавление нестатического или константного члена в B приведет к ответу «10», добавление нетривиального конструктора или статического — нет.

PS. Во втором примере

enum A : int { X, Y };
enum B : int { Z };

Совместимость макетов между этими двумя здесь определяется C++ 14, и они не совместимы с базовым типом (но конвертируемы). хотя что-то вроде

 enum A a = Y;
 enum B b = (B*)a;

может привести к неопределенному поведению, как если бы вы попытались отобразить float с произвольным 32-битным значением.

Я думаю, что ваш код UB, так как вы разыменовываете указатель, полученный в результате приведения, который нарушает введите правила псевдонимов.

Теперь, если вы активируете флаг строгого алиасинга, вы позволяете компилятору оптимизировать код для UB. Как использовать этот UB, зависит от компилятора. Вы можете увидеть ответы на этот вопрос.

Что касается gcc, документация для -fstrict-aliasing показывает, что он может оптимизировать на основе:

(...) предполагается, что объект одного типа никогда не находится по тому же адресу, что и объект другого типа, если только типы не почти одинаковы.

Мне не удалось найти определение для «почти одинакового», но два класса с абсолютно одинаковым макетом могут считаться «почти одинаковыми», и они не учитываются при оптимизации.

Я считаю, что следующее является допустимым С++ (без вызова UB):

#include <new>

struct A {
  int a;
};

struct B : A {
  // int x;
};

static A a;

int g(B *b);
int g(B *b) {
   a.a = 10;
   b->a++;
   return a.a;
}

int f();
int f() {
  auto p = new (&a) B{};
  return g(p);
}

потому что (глобальный) a всегда ссылается на объект типа A (даже если он является подобъектом B-объекта после вызова f()), а p указывает на объект типа B.

Если вы отметите a как длительность хранения static (как я сделал выше), все протестированные мной компиляторы с радостью применят строгое сглаживание и оптимизируют для возврата 10.

С другой стороны, если вы пометите g() __attribute__((noinline)) или добавите функцию h(), которая возвращает указатель на a

A* h();
A* h() { return &a; }

компиляторы, которые я тестировал, предполагают, что &a и параметр b могут использовать псевдоним и перезагружать значение.