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

    • Если я правильно понял, это же просто стресс-тест для компилятора.
      Ответить
      • Ага, походу тесты на поддержку лимитов.

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

        EXPAND_4096_CASES

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

          #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)
          из которого АВТОМАТИЧЕСКИ бы делалась остальная шняна
          Ответить
          • BOOST_PP_REPEAT и их друзья помогут.
            Ответить
            • вполне вероятно этот тест и навеян BOOST_PP (и линух кернелом).
              Ответить
        • По сути, если бы было возможно такое рекурсивное определение макросов...
          Получается, рекурсия заменена копипастом
          Ответить
    • ПОСОНЫ НЕ ЗАПУСКАЙТИ ТАМ МАКРОС!!! У МЕНЯ ОТ ЕТОЙ ХУЙНИ ПРЕПРОЦЕССОР РАСПИДОРАСИЛО ГЦЦ УМЕР ПИШУ С БРЕЙНФАКА
      Ответить
      • Макро-бомба оттуда же:
        #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
        Ответить

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