Является ли пометка указателя в C неопределенной в соответствии со стандартом?

Некоторые динамически типизированные языки используютпометку указателя как быстрый способ определить или сузить тип времени выполнения представляемого значения. Классический способ сделать это-преобразовать указатели в целое число подходящего размера и добавить значение тега над наименее значимыми битами, которые, как предполагается, равны нулю для выровненных объектов. Когда объект нуждается в доступе, биты тега маскируются, целое число преобразуется в указатель, и указатель разыменовывается как нормальный.

Это само по себе все в порядке, за исключением того, что все это зависит от одного колоссального предположения: что выровненный указатель преобразуется в целое число, гарантированно имеющее нулевые биты в нужных местах. Можно ли гарантировать это в соответствии с буквой стандарта?

---

Хотя в стандартном разделе 6.3.2.3 (ссылки на проект C11) говорится, что результат преобразования указателя в целое определяется реализацией, мне интересно, что эффективно ли арифметические правила указателя в 6.5.2.1 и 6.5.6 ограничивают результат преобразования указателя - > целого числа, чтобы следовать тем же предсказуемым арифметическим правилам, которые уже предполагают многие программы. (6.3.2.3 Примечание 67, по-видимому, предполагает, что это является предполагаемым духом стандарта в любом случае, не то чтобы это много значит.)

Я специально думаю о случае, когда можно выделить большой массив, чтобы он действовал как куча для динамического языка, и, следовательно, указатели мы говорим об элементах этого массива. Я предполагаю, что начало самого c-распределенного массива может быть помещено в выровненное положение с помощью некоторых вторичных средств (хотя, конечно, обсудите это тоже). Допустим, у нас есть массив восьмибайтовых "минусов ячеек"; можем ли мы гарантировать, что указатель на любую данную ячейку преобразуется в целое число с наименьшими тремя битами, свободными для тега?

Например:

typedef Cell ...; // such that sizeof(Cell) == 8
Cell heap[1024];  // such that ((uintptr_t)&heap[0]) & 7 == 0

((char *)&heap[11]) - ((char *)&heap[10]); // == 8
(Cell *)(((char *)&heap[10]) + 8);         // == &heap[11]
&(&heap[10])[0];                           // == &heap[10]
0[heap];                                   // == heap[0]

// So...
&((char *)0)[(uintptr_t)&heap[10]];        // == &heap[10] ?
&((char *)0)[(uintptr_t)&heap[10] + 8];    // == &heap[11] ?

// ...implies?
(Cell *)((uintptr_t)&heap[10] + 8);        // == &heap[11] ?

(Если я правильно понимаю, если реализация обеспечивает uintptr_t, то неопределенное поведение, о котором говорится в пункте 6.3.2.3, не имеет значения, верно?)

Если все это верно, то я бы предположил, что это означает, что вы можете на самом деле полагаться на младшие биты любого преобразованного указателя на элемент выровненного массива Cell, чтобы быть свободным для тегирования. Делают ли они и делает ли это?

(Насколько я знаю, этот вопрос гипотетичен, поскольку нормальное предположение справедливо для общих платформ в любом случае, и если вы нашли одну, где ее не было, вы, вероятно, не захотите смотреть на Стандарт C для руководства, а не документы платформы; но это к делу не относится.)