C, препроцессор и размер/выравнивание типов

#define SIZEOF_typename 4

Буду оригинален:

#define SIZEOF_typename (sizeof(typename))

#define ALIGNMENT_OF_typename 4

ВНЕЗАПНО

#define ALIGN_OF_X (alignof(x))

в нём есть вычисления через препроцессор

Вычисления вычислениями рознь. Если "вычисления" обычные Си-выражения - то решение выше. Если там дичь уровня

#if VAR == SOME_DEFINE
...
#elif OTHERVAR >= SOME_OTHER_DEFINE
...
#endif

то только руками под каждую из платформ.

Вместо alignof(x) в компиляторах, которые его нативно не поддерживают, можно сделать такое:

typedef struct { char a; x b; } _alignstruct_X;
#define ALIGN_OF_X ((size_t)&(((_alignstruct_X*)0)->b))

Разумеется, препроцессорные вычисления с этим работать не будут, но тут без шансов: все типы считаются компилятором, который логически (да, технически уже не так) запускается на уже препроцессированном исходнике, отправить из него данные «в прошлое» нельзя.

А, я что-то упустил из виду: код запускать нельзя, хорошо, но компилятор то можно запустить ещё раз?

Пишем такую штуку (отдельный исходник) align_test.c:

typedef struct { char a; TYPE b; } _alignstruct_X;
#define ALIGN_OF_X ((unsigned long)&(((_alignstruct_X*)0)->b))
int a[(ALIGN_OF_X==TEST)?1:-1];
int main(void) { return 0; }

#!/bin/sh -e

TYPE="$1"
AMACRO="$2"
TEST=1

while ! gcc "-DTYPE=$TYPE" -DTEST=$TEST align_test.c -c -o /dev/null >> /dev/null 2>&1; do
  TEST=`expr $TEST + 1`
  if [ $TEST -gt 1000 ]; then
    echo "something went wrong, can't check alignment of type \"$TYPE\"" 1>&2
    exit 1
  fi
done

echo "#define ALIGN_OF_$AMACRO $TEST"

Запускаешь:

./align_test.sh "unsigned long" ULONG >> config.h

Ну и для sizeof аналогично.

Учти, что для ненативных типов вроде size_t надо инклюдить ещё какой-то хедер в align_test.c, иначе он молча повисит несколько минут и напишет что ничего не вышло. Чтобы заранее выяснить, доступен ли такой тип при данных хедерах - можно поптыаться скомпилировать предварительно ещё один исходник где этим типов просто переменная будет объявлена.

Если там дичь уровня

Там дичь уровня :(

но компилятор то можно запустить ещё раз?

Да, без проблем.

И скрипт align_test.sh:

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

Убери >> /dev/null 2>&1 от вывода gcc и увидишь в чём дело.

Кстати переменную наверно лучше засунуть внутрь main() а то у меня gcc на неё какой-то непонятный варнинг пишет (внутри main Не пишет), вдруг сломается через ещё 15 версий.

Ну и? int a[-1] это ошибка компиляции, он падает и цикл скрипта идёт дальше перебирать варианты.

Ну и? int a[-1] это ошибка компиляции, он падает и цикл скрипта идёт дальше перебирать варианты.

А… пожжи, то есть оно перебирает все варианты пока не найдёт нужный? Понял. Спасибо.

Да, автоконф делает так же, только почему-то в его случае это не работает. Попробую руками закостылить.

В препроцессоре нельзя, но можно сделать static_assert в компиляции

int x[(sizeof(int) == 4)?1:-1];

Можно попробовать вывести посредством #pragma message и вытащить значение из выхлопа компилятора

А… пожжи, то есть оно перебирает все варианты пока не найдёт нужный? Понял. Спасибо.

И автолулзы и симейк таким образом пытаются понять возможности платформы.

Если нет желания на это закладываться, то только руками.

Ну по идее есть *_MAX всякие для всех стандартных типов, а в c23 есть ещё и *_WIDTH.

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

Ну либо просто портянку макросов под все нужные типы с проверками границ.

Ну и static_assert не забыть, что полученное совпадает с sizeof/alignof.

А со структурами это будет работать? И как тут выравнивание получить? Оно меня куда больше интересует.

А со структурами это будет работать?

Будет.

И как тут выравнивание получить? Оно меня куда больше интересует.

Уже предложенными выше способами. Любая магия препроцессора, а весь генерируемый код – один байт в секции «.data». Вне gcc+binutils не проверял. Поэкспериментируй.

собирать такой объектник отдельным «проектом» с стандартами в которых есть alignof,

Запускать код при этом нельзя, потому что кросскомпиляция, смерть, жопа и сотона

Мы при сборке ядра через qemu depmod запускали, думаю, что для простеньких конфигурационных тестов это тоже вариант

я обычно так костыляю на коленке

https://stackoverflow.com/a/2008577

Вспомнил, что в разных версиях gcc/binutils менялись умолчания в какие секции отправлять символы и аттрибуты самих секций. Вдруг когда-нибудь там появится набивка или ещё что-то пойдёт не так. Ещё способ (bonus: однострочник).

> echo "char i = sizeof(int);" | \
> gcc -x c -S -o- - | \
> grep byte | \
> cut -f 3

4

Мы при сборке ядра через qemu depmod запускали, думаю, что для простеньких конфигурационных тестов это тоже вариант

Туда нет qemu. Это всё ещё x86_64/arm64, просто ОС куда более нишевая.

А можешь плз объяснить эту особую магию?

Пишешь код:

switch(sizeof(typename)) {
  case 2:
    break;
  case 4:
    break;
  case 8:
    break;
  case TEST_SIZE:
    break;
}

Я разобрался, почему AC_COMPUTE_INT, который делает тест в духе того что firkax написал, сыпался.

У меня тут слегка кастомная libc и там offsetof() был задан макросом #define offsetof(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT)).

GCC почему-то считает, что результат этого не является константным выражением и генерит код с VLA, который сыпется и не может. При замене макроса на #define offsetof(TYPE, ELEM) __builtin_offsetof(TYPE, ELEM) всё магически заработало.

Честно говоря, я до сих пор в шоке от того, каким же чудовищным говноязыком является этот ваш Си и что в нём нельзя просто получить статические данные без разрыва жопы.

А как выглядит это VLA от константы?

Массив с выражением с offsetof в качестве размера компилятором считался как VLA. То есть GCC не осилил распознать результат того макроса за константу.

GCC почему-то считает, что результат этого не является константным выражением и генерит код с VLA,

У тебя либо под целевую платформу gcc рабоает через пень колоду, либо структура описана через жопу. Вот как выглядит реализация этого макроса обёрнутая в функцию под amd64:

.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$8, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc

либо под целевую платформу gcc рабоает через пень колоду,

Там x86_64, просто остальная часть таргета всратая.

либо структура описана через жопу

Код из теста автолулзов, очищенный от мусора:

#include <stdio.h>

int
main ()
{
  static int test_array [1 - 2 * !((offsetof(struct { char c; char ty; },ty)) >= 0)];
  test_array [0] = 0;
  return test_array [0];
}

Это не мой код. Это автолулзы такое говно для тестов генерят.

Это я понял, а как выглядел этот VLA в результате то?

УМВР

https://godbolt.org/z/YWdvq98on

#include <stdio.h>

#define offsetof(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))

struct st { int x,a; };
int main(void) {
    int v[(offsetof(struct st, a)==4)?-1:0];
    printf("%u", (unsigned)offsetof(struct st, a));
    printf("%u", (unsigned)sizeof(v));
    return 0;
}

Код из теста автолулзов, очищенный от мусора:

Успешно компилируется в валидный код:

main:
.LFB1:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$0, test_array.0(%rip)
	movl	test_array.0(%rip), %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc

Это я понял, а как выглядел этот VLA в результате то?

А.. понятия не имею. Я просто словил ошибку компилятора, указывающую на VLA, в какой-то момент. Собрал с -Werror=vla и потом поправил макрос на __builtin_offsetof. Дальше я копать это всё даже близко не хочу. В тред отписался скорее для будущих поколений, вдруг кто ещё в такое говно вляпается.

Ты лучше отпишись, под какую платформу ты скачешь по всем этим граблям, потому как по описанию ты чуть ли не первопроходец.

Ты лучше отпишись, под какую платформу ты скачешь по всем этим граблям

С точки зрения GCC, это всё идёт с -ffreestanding.

потому как по описанию ты чуть ли не первопроходец

Ну, не совсем. Но штука крайне нишевая.

Хм,

https://godbolt.org/z/zoYGrzGn7

#include <stdio.h>

int main(void) {
    static int v[(size_t)&(*(int*)0)];
    return 0;
}

И правда ругается даже на такое. А не ругался в моём примере выше из-за того что там переменная не static - то есть ругань на static vla который запрещён.

Посмотри на разных версиях gcc, godbolt показывает что 4.4 компилирует подобное а 4.5 уже падает.

И правда ругается даже на такое.

Так ты шизу написал. У тебя объект нулевого размера.

Попробуй скомпилировать, он не на ноль ругается. Или поставь туда единицу и увидь что ничего не поменялось.

он не на ноль ругается.

Потому что расширениями компилятора для тонн юниксового struct { ..., char[0]} нулевые массивы допустимы, но трактуются как VLA. Ну а static VLA - это такое себе. Шланг, к слову, всё выводит и комплирует, но запись в жалобную книгу делает.

С точки зрения GCC, это всё идёт с -ffreestanding.

Это либы, это не основное. Основное - под какой набор инструкций у тебя кодеген.

С точки зрения GCC, это всё идёт с -ffreestanding.

Это либы, это не основное. Основное - под какой набор инструкций у тебя кодеген.

Выше писал же, x86_64.

Тогда не понятно, как ты под эту свою защищенную ось косперского ловишь такие ошибки компиляции. GCC чтоле тоже какой-то защищённый.

Тогда не понятно, как ты под эту свою защищенную ось косперского ловишь такие ошибки компиляции.

Я пока виню во всём автолулзы. Их код для тестов просто чудовищен зачастую.

GCC чтоле тоже какой-то защищённый.

Нет, вполне обычный из дистра.

Их код для тестов просто чудовищен зачастую.

Ну напши лучше, то что он делает:

Macro: AC_COMPUTE_INT (var, expression, [includes = ‘AC_INCLUDES_DEFAULT’], [action-if-fails])
Store into the shell variable var the value of the integer expression. The value should fit in an initializer in a C variable of type signed long. To support cross compilation (in which case, the macro only works on hosts that use twos-complement arithmetic), it should be possible to evaluate the expression at compile-time.

Давай посмотрим, насколько ты сделаешь лучше. ;)

Я пока виню во всём автолулзы.

А надо бы того, кто под x86_64 переизобретает stdint / stddef. Это какая-то особая форма спецолимпиады.

Давай посмотрим, насколько ты сделаешь лучше. ;)

Слушай, сам факт того, что из компилятора приходится выковыривать информацию о выравнивании вот таким вот чудовищным способом, является просто безумием. Это удаление гланд через три чужих жопы из четвёртой.

сам факт того, что из компилятора приходится выковыривать информацию о выравнивании вот таким вот чудовищным способом,

У тебя есть другой способ выковыривать информацию о выравнивании с помощью языка программирования, где нет концепции выравнивания? На 99.9(9)% других языков ты вообще не сможешь этого сделать.

У тебя есть другой способ выковыривать информацию о выравнивании с помощью языка программирования, где нет концепции выравнивания?

В Си есть концепт выравнивания.

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

В Си есть концепт выравнивания

Нет, в Си как языке программирования нет концепции выравнивания. Это деталь имплементации, важная для реализации компилятора / целевой платформы.

Если ты сам лично не начнёшь шалить ручками с объектами в памяти приведением указателей, ты можешь прожить всю жизнь, написав тонны кода на си, и никогда ничего про выравнивание не знать. Как собственно и обстоят дела у 99% сишников.

У меня тут слегка кастомная libc и там offsetof() был задан

🤦‍♂️

GCC почему-то считает, что результат этого не является константным выражением

А почему он должен считать это константным выражением?

При замене макроса

🤦‍♂️

Нормальные люди не маются дурью и берут offsetof из stddef.h

Нет, в Си как языке программирования нет концепции выравнивания. Это деталь имплементации, важная для реализации компилятора / целевой платформы.

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2310.pdf

Пункт 6.2.8, «Alignment of objects». Читаем, просвещаемся.

Как собственно и обстоят дела у 99% сишников.

У 99% сишников дела обстоят откровенно говоря херово, они не умеют писать на своём языке и делают полное говно.

А почему он должен считать это константным выражением?

Потому что это константное выражение. Например, его можно записать в constexpr.

Нормальные люди не маются дурью и берут offsetof из stddef.h

Кастомный таргет со своей libc. stddef.h тут пишем тоже мы. Был вариант попробовать портировать musl, но там смерть-жопа-сотона. Вообще внезапно переносимых libc под freestanding target кот наплакал.