Реализация вложенных функций

Недавно я узнал, что gcc разрешает определение вложенной функции. На мой взгляд, это классная функция, но мне интересно, как ее реализовать.

В то время как нетрудно реализовать прямые вызовы вложенных функций, передав указатель контекста в качестве скрытого аргумента, gcc также позволяет взять указатель на вложенную функцию и передать этот указатель на произвольную другую функцию, которая, в свою очередь, может вызовите вложенную функцию контекста. Поскольку функция, вызывающая вложенную функцию, имеет только тип вложенной функции для вызова, она явно не может передать указатель контекста.

Я знаю, что другие языки, такие как Haskell, которые имеют более запутанное соглашение о вызове, позволяют частичному приложению поддерживать такой материал, но я не вижу возможности сделать это на C. Как это возможно реализовать?

Вот небольшой пример случая, который иллюстрирует проблему:

int foo(int x,int(*f)(int,int(*)(void))) {
  int counter = 0;
  int g(void) { return counter++; }

  return f(x,g);
}

Эта функция вызывает функцию, вызывающую функцию, которая возвращает счетчик из контекста и одновременно увеличивает его.

Ответы

Ответ 1

GCC использует что-то, называемое батутом.

Информация: http://gcc.gnu.org/onlinedocs/gccint/Trampolines.html

Батут - это часть кода, который GCC создает в стеке, чтобы использовать, когда вам нужен указатель на вложенную функцию. В вашем коде батут необходим, потому что вы передаете g в качестве параметра вызова функции. Батут инициализирует некоторые регистры, так что вложенная функция может ссылаться на переменные во внешней функции, затем она переходит к самой вложенной функции. Батуты очень маленькие - вы "отскакиваете" от батута и в тело вложенной функции.

Использование вложенных функций таким образом требует исполняемого стека, который в наши дни не рекомендуется. На самом деле его нет.

Расчленение батута:

Вот пример вложенной функции в расширенном CCC C:

void func(int (*param)(int));

void outer(int x)
{
    int nested(int y)
    {
        // If x is not used somewhere in here,
        // then the function will be "lifted" into
        // a normal, non-nested function.
        return x + y;
    }
    func(nested);
}

Это очень просто, поэтому мы можем видеть, как это работает. Вот результирующая сборка outer, минус некоторые вещи:

subq    $40, %rsp
movl    $nested.1594, %edx
movl    %edi, (%rsp)
leaq    4(%rsp), %rdi
movw    $-17599, 4(%rsp)
movq    %rsp, 8(%rdi)
movl    %edx, 2(%rdi)
movw    $-17847, 6(%rdi)
movw    $-183, 16(%rdi)
movb    $-29, 18(%rdi)
call    func
addq    $40, %rsp
ret

Вы заметите, что большая часть того, что он делает, записывает регистры и константы в стек. Мы можем следовать и находим, что при SP + 4 он помещает 19-байтовый объект со следующими данными (в синтаксисе GAS):

.word -17599
.int $nested.1594
.word -17847
.quad %rsp
.word -183
.byte -29

Это достаточно просто, чтобы пройти через дизассемблер. Предположим, что $nested.1594 - 0x01234567, а %rsp - 0x0123456789abcdef. В результате разборки, предоставляемой objdump, является:

   0:   41 bb 67 45 23 01       mov    $0x1234567,%r11d
   6:   49 ba ef cd ab 89 67    mov    $0x123456789abcdef,%r10
   d:   45 23 01 
  10:   49 ff e3                rex.WB jmpq   *%r11

Итак, батут загружает указатель стека внешней функции в %r10 и переходит к вложенному телу функции. Тело вложенной функции выглядит следующим образом:

movl    (%r10), %eax
addl    %edi, %eax
ret

Как вы можете видеть, вложенная функция использует %r10 для доступа к внешним переменным функции.

Конечно, это довольно глупо, что батут больше, чем сама вложенная функция. Вы могли бы легко сделать лучше. Но не очень многие люди используют эту функцию, и таким образом батут может оставаться одного и того же размера (19 байтов) независимо от того, насколько велика вложенная функция.

Заключительное примечание. В нижней части сборки есть окончательная директива:

.section        .note.GNU-stack,"x",@progbits

Это указывает компоновщику отмечать стек как исполняемый файл.