1. Си / Говнокод #16026

    +135

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    // Hammer the CFG with large numbers of overlapping variable scopes, which
// implicit destructors triggered at each edge.

#define EXPAND_BASIC_STRUCT(i) struct X##i { X##i(int); ~X##i(); };
#define EXPAND_NORET_STRUCT(i) struct X##i { X##i(int); ~X##i() __attribute__((noreturn)); };
EXPAND_BASIC_STRUCT(0000); EXPAND_NORET_STRUCT(0001);
EXPAND_BASIC_STRUCT(0010); EXPAND_BASIC_STRUCT(0011);
EXPAND_BASIC_STRUCT(0100); EXPAND_NORET_STRUCT(0101);
EXPAND_NORET_STRUCT(0110); EXPAND_BASIC_STRUCT(0111);
EXPAND_BASIC_STRUCT(1000); EXPAND_NORET_STRUCT(1001);
EXPAND_BASIC_STRUCT(1010); EXPAND_BASIC_STRUCT(1011);
EXPAND_NORET_STRUCT(1100); EXPAND_NORET_STRUCT(1101);
EXPAND_BASIC_STRUCT(1110); EXPAND_BASIC_STRUCT(1111);

#define EXPAND_2_VARS(c, i, x)  const X##i var_##c##_##i##0(x), &var_##c##_##i##1 = X##i(x)
#define EXPAND_4_VARS(c, i, x)  EXPAND_2_VARS(c, i##0, x);  EXPAND_2_VARS(c, i##1, x)
#define EXPAND_8_VARS(c, i, x)  EXPAND_4_VARS(c, i##0, x);  EXPAND_4_VARS(c, i##1, x)
#define EXPAND_16_VARS(c, i, x) EXPAND_8_VARS(c, i##0, x);  EXPAND_8_VARS(c, i##1, x)
#define EXPAND_32_VARS(c, x)    EXPAND_16_VARS(c, 0, x);    EXPAND_16_VARS(c, 1, x)

#define EXPAND_2_INNER_CASES(i, x, y)    INNER_CASE(i, x, y);             INNER_CASE(i + 1, x, y);
#define EXPAND_4_INNER_CASES(i, x, y)    EXPAND_2_INNER_CASES(i, x, y)    EXPAND_2_INNER_CASES(i + 2, x, y)
#define EXPAND_8_INNER_CASES(i, x, y)    EXPAND_4_INNER_CASES(i, x, y)    EXPAND_4_INNER_CASES(i + 4, x, y)
#define EXPAND_16_INNER_CASES(i, x, y)   EXPAND_8_INNER_CASES(i, x, y)    EXPAND_8_INNER_CASES(i + 8, x, y)
#define EXPAND_32_INNER_CASES(i, x, y)   EXPAND_16_INNER_CASES(i, x, y)   EXPAND_16_INNER_CASES(i + 16, x, y)

#define EXPAND_2_OUTER_CASES(i, x, y)    OUTER_CASE(i, x, y);             OUTER_CASE(i + 1, x, y);
#define EXPAND_4_OUTER_CASES(i, x, y)    EXPAND_2_OUTER_CASES(i, x, y)    EXPAND_2_OUTER_CASES(i + 2, x, y)
#define EXPAND_8_OUTER_CASES(i, x, y)    EXPAND_4_OUTER_CASES(i, x, y)    EXPAND_4_OUTER_CASES(i + 4, x, y)
#define EXPAND_16_OUTER_CASES(i, x, y)   EXPAND_8_OUTER_CASES(i, x, y)    EXPAND_8_OUTER_CASES(i + 8, x, y)
#define EXPAND_32_OUTER_CASES(i, x, y)   EXPAND_16_OUTER_CASES(i, x, y)   EXPAND_16_OUTER_CASES(i + 16, x, y)

    Рекурсивное (EXPAND_... ) макроговно из clang и генератор (EXPAND_..._STRUCT) структур через какую-то непонятную жопу
    https://github.com/llvm-mirror/clang/blob/master/INPUTS/cfg-nested-var-scopes.cpp

    Запостил: j123123, 21 Мая 2014

    Комментарии (8) RSS

    • ava WGH 21.05.2014 01:30 # +1

      Если я правильно понял, это же просто стресс-тест для компилятора.
      Ответить

      • ava bormand 21.05.2014 05:55 # 0

        Ага, походу тесты на поддержку лимитов.

        https://github.com/llvm-mirror/clang/blob/master/INPUTS/cfg-big-switch.c

        EXPAND_4096_CASES

        > Рекурсивное
        Где здесь рекурсия, j123123?
        Ответить

        • ava j123123 21.05.2014 10:05 # 0

          Вот:

          #define EXPAND_2_VARS(c, i, x) const X##i var_##c##_##i##0(x), &var_##c##_##i##1 = X##i(x)
          #define EXPAND_4_VARS(c, i, x) EXPAND_2_VARS(c, i##0, x); EXPAND_2_VARS(c, i##1, x)

          Если бы сишный препроцессор был неговном, можно было бы

          #define EXPAND_(X)_VARS(c, i, x) EXPAND_(x/2)_VARS(c, i##0, x); EXPAND_(x/2)_VARS(c, i##1, x)

          И это бы рекурсивно прожевывало все варианты вида
          EXPAND_(4)_VARS
          EXPAND_(8)_VARS
          EXPAND_(16)_VARS
          ну и так далее. Нужно было бы только оставить
          #define EXPAND_2_VARS(c, i, x) const X##i var_##c##_##i##0(x), &var_##c##_##i##1 = X##i(x)
          из которого АВТОМАТИЧЕСКИ бы делалась остальная шняна
          Ответить

          • ava bormand 21.05.2014 10:11 # 0

            BOOST_PP_REPEAT и их друзья помогут.
            Ответить

            • ava Dummy00001 22.05.2014 16:25 # 0

              вполне вероятно этот тест и навеян BOOST_PP (и линух кернелом).
              Ответить

        • ava j123123 21.05.2014 10:10 # 0

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

    • ava 3.14159265 21.05.2014 02:26 # +8

      ПОСОНЫ НЕ ЗАПУСКАЙТИ ТАМ МАКРОС!!! У МЕНЯ ОТ ЕТОЙ ХУЙНИ ПРЕПРОЦЕССОР РАСПИДОРАСИЛО ГЦЦ УМЕР ПИШУ С БРЕЙНФАКА
      Ответить

      • ava bormand 21.05.2014 06:07 # +2

        Макро-бомба оттуда же:
        #define A0 a b
#define A1 A0 A0 A0 A0 A0 A0
#define A2 A1 A1 A1 A1 A1 A1
#define A3 A2 A2 A2 A2 A2 A2
#define A4 A3 A3 A3 A3 A3 A3
#define A5 A4 A4 A4 A4 A4 A4
#define A6 A5 A5 A5 A5 A5 A5
#define A7 A6 A6 A6 A6 A6 A6
#define A8 A7 A7 A7 A7 A7 A7

A8
        Ответить

    Добавить комментарий