Директен достъп до функционалния стек

Много „ако“:

1. Придържате се към една версия на компилатор.
2. Един набор от опции на компилатора.
3. По някакъв начин успейте да убедите вашия компилатор никога да не предава аргументи в регистрите.
4. Убедете вашия компилатор да не третира две извиквания f(5, "foo") и f(&i, 3.14) с различни аргументи към една и съща функция като грешка. (Това беше характеристика например на ранните C компилатори на DeSmet).

Тогава записът за активиране на функция е предсказуем (т.е. гледате генерирания сбор и предполагате, че винаги ще бъде един и същ): адресът за връщане ще бъде някъде там и запазеният bp (базов указател, ако вашата архитектура има такъв) и последователността на аргументите ще бъде същата. И така, как бихте знаели какви действителни параметри са предадени? Ще трябва да ги кодирате (техния размер, отместване), вероятно в първия аргумент, нещо като това, което прави printf.

Рекурсия (т.е. да бъдеш в рекурсивно повикване няма значение) всеки екземпляр има свой запис за активиране (казах ли, че трябва да убедиш своя компилатор никога да не оптимизира опашните извиквания?), но в C, за разлика от Pascal, нямаш връзка обратно към записа за активиране на повикващия (т.е. локални променливи), тъй като няма декларации на вложени функции. Получаването на достъп до пълния стек, т.е. всички записи за активиране преди текущия екземпляр, е доста досадно, податливо на грешки и представлява интерес най-вече за авторите на зловреден код, които биха искали да манипулират адреса за връщане.

Така че това е много караница и предположения за нищо.

Да, можете да получите достъп до предадените параметри директно чрез стека. Но не, не можете да използвате дефиниция на функция в стар стил, за да създадете функция с променлив брой и тип параметри. Следният код показва как да получите достъп до параметър чрез указател на стека. Той е напълно зависим от платформата, така че нямам представа дали ще работи на вашата машина или не, но можете да схванете идеята

long foo();

int main(void)
{
    printf( "%lu",foo(7));
}

long foo(x)
 long x;
{
    register void* sp asm("rsp");
    printf("rsp = %p rsp_ value = %lx\n",sp+8, *((long*)(sp + 8)));
    return *((long*)(sp + 8)) + 12;
}

1. вземете указател на главата на стека (rsp регистър на моята машина)
2. добавете отместването на подаден параметър към rsp => получавате указател към long x в стека
3. деименирайте указателя, добавете 12 (направете каквото трябва) и върнете стойността.

Отместването е проблемът, тъй като зависи от компилатора, операционната система и кой знае какво още. За този пример просто проверих, проверих го в дебъгера, но ако е наистина важно за вас, мисля, че можете да дойдете с някакво "общо" решение за вашата машина.

Ако декларирате void foo(), тогава ще получите грешка при компилиране за foo("dummy1", "dummy2").

Можете да декларирате функция, която приема неопределен брой аргументи, както следва (например):

int func(char x,...);

Както можете да видите, поне един аргумент трябва да бъде посочен. Това е така, че във функцията да имате достъп до всички аргументи, които следват последния указан аргумент.

Да предположим, че имате следното обаждане:

short y = 1000;
int sum = func(1,y,5000,"abc");

Ето как можете да приложите func и да получите достъп до всеки от неуточнените аргументи:

int func(char x,...)
{
    short y = (short)((int*)&x+1)[0]; // y = 1000
    int   z = (int  )((int*)&x+2)[0]; // z = 5000
    char* s = (char*)((int*)&x+3)[0]; // s[0...2] = "abc"
    return x+y+z+s[0];                // 1+1000+5000+'a' = 6098
}

Проблемът тук, както можете да видите, е, че типът на всеки аргумент и общият брой на аргументите са неизвестни. Така че всяко извикване на func с "неподходящ" списък от аргументи може (и вероятно ще доведе) до изключение по време на изпълнение.

Следователно, обикновено първият аргумент е низ (const char*), който показва типа на всеки от следващите аргументи, както и общия брой на аргументите. Освен това има стандартни макроси за извличане на неуказаните аргументи - va_start и va_end.

Например, ето как можете да приложите функция, подобна по поведение на printf:

void log_printf(const char* data,...)
{
    static char str[256] = {0};
    va_list args;
    va_start(args,data);
    vsnprintf(str,sizeof(str),data,args);
    va_end(args);
    fprintf(global_fp,str);
    printf(str);
}

P.S.: примерът по-горе е не безопасен за нишки и е даден тук само като пример...