Cの可変機能関数の呼び出しを転送する
Cでは、可変個の関数の呼び出しを転送できますか？のように、
int my_printf(char *fmt, ...) {
fprintf(stderr, "Calling printf with fmt %s", fmt);
return SOMEHOW_INVOKE_LIBC_PRINTF;
}
この場合、上記の方法で呼び出しを転送することは明らかに他の方法で呼び出しを記録したり、vfprintfを使用したりできるため、厳密に必要ではありませんが、私が取り組んでいるコードベースはラッパーに実際の作業を要求し、 'vfprintfに似たヘルパー関数を持たない（追加できない）。
[更新：これまでに提供された回答に基づいた混乱があるようです。質問を別の方法で表現するには：一般に、任意の可変引数関数をラップできますか その関数の定義を変更せずに。]
可変数の引数の代わりにva_listを取るvfprintfに類似した関数がない場合、できません。 http://c-faq.com/varargs/handoff.html を参照してください。
例：
void myfun(const char *fmt, va_list argp) {
vfprintf(stderr, fmt, argp);
}
直接ではありませんが、可変個の関数がvarargsスタイルの代替関数とペアになるのは一般的です（そして、標準ライブラリの場合はほぼ例外なく見つかります）。例えばprintf/vprintf
V ...関数はva_listパラメータを取ります。その実装は多くの場合、コンパイラ固有の「マクロマジック」で行われますが、次のような可変引数関数からv ...スタイル関数を呼び出すと動作することが保証されます。
#include <stdarg.h>
int m_printf(char *fmt, ...)
{
int ret;
/* Declare a va_list type variable */
va_list myargs;
/* Initialise the va_list variable with the ... after fmt */
va_start(myargs, fmt);
/* Forward the '...' to vprintf */
ret = vprintf(fmt, myargs);
/* Clean up the va_list */
va_end(myargs);
return ret;
}
これにより、探している効果が得られます。
可変個のライブラリ関数の作成を検討している場合は、ライブラリの一部としてva_listスタイルのコンパニオンを使用可能にすることも検討する必要があります。あなたの質問からわかるように、それはあなたのユーザーにとって有用であることが証明できます。
C99は 可変引数を持つマクロ ;をサポートします。コンパイラーによっては、必要なことを行うマクロを宣言できる場合があります。
#define my_printf(format, ...) \
do { \
fprintf(stderr, "Calling printf with fmt %s\n", format); \
some_other_variadac_function(format, ##__VA_ARGS__); \
} while(0)
ただし、一般的に、最適な解決策は、ラップしようとしている関数のva_list形式を使用することです（存在する場合）。
ほとんど、<stdarg.h>で利用可能な機能を使用します：
#include <stdarg.h>
int my_printf(char *format, ...)
{
va_list args;
va_start(args, format);
int r = vprintf(format, args);
va_end(args);
return r;
}
プレーンなvprintfではなく printf バージョンを使用する必要があることに注意してください。 va_listを使用せずに、この状況で可変長関数を直接呼び出す方法はありません。
このような呼び出しを素敵な方法で転送することは実際には不可能であるため、元のスタックフレームのコピーを使用して新しいスタックフレームを設定することで、この問題を回避しました。ただし、これは非常に移植性が低く、あらゆる種類の仮定を行います、たとえばコードがフレームポインターと「標準」呼び出し規約を使用していること。
このヘッダーファイルにより、x86_64およびi386（GCC）の可変機能関数をラップできます。浮動小数点引数では機能しませんが、それらをサポートするために拡張するのは簡単です。
#ifndef _VA_ARGS_WRAPPER_H
#define _VA_ARGS_WRAPPER_H
#include <limits.h>
#include <stdint.h>
#include <alloca.h>
#include <inttypes.h>
#include <string.h>
/* This macros allow wrapping variadic functions.
* Currently we don't care about floating point arguments and
* we assume that the standard calling conventions are used.
*
* The wrapper function has to start with VA_WRAP_PROLOGUE()
* and the original function can be called by
* VA_WRAP_CALL(function, ret), whereas the return value will
* be stored in ret. The caller has to provide ret
* even if the original function was returning void.
*/
#define __VA_WRAP_CALL_FUNC __attribute__ ((noinline))
#define VA_WRAP_CALL_COMMON() \
uintptr_t va_wrap_this_bp,va_wrap_old_bp; \
va_wrap_this_bp = va_wrap_get_bp(); \
va_wrap_old_bp = *(uintptr_t *) va_wrap_this_bp; \
va_wrap_this_bp += 2 * sizeof(uintptr_t); \
size_t volatile va_wrap_size = va_wrap_old_bp - va_wrap_this_bp; \
uintptr_t *va_wrap_stack = alloca(va_wrap_size); \
memcpy((void *) va_wrap_stack, \
(void *)(va_wrap_this_bp), va_wrap_size);
#if ( __WORDSIZE == 64 )
/* System V AMD64 AB calling convention */
static inline uintptr_t __attribute__((always_inline))
va_wrap_get_bp()
{
uintptr_t ret;
asm volatile ("mov %%rbp, %0":"=r"(ret));
return ret;
}
#define VA_WRAP_PROLOGUE() \
uintptr_t va_wrap_ret; \
uintptr_t va_wrap_saved_args[7]; \
asm volatile ( \
"mov %%rsi, (%%rax)\n\t" \
"mov %%rdi, 0x8(%%rax)\n\t" \
"mov %%rdx, 0x10(%%rax)\n\t" \
"mov %%rcx, 0x18(%%rax)\n\t" \
"mov %%r8, 0x20(%%rax)\n\t" \
"mov %%r9, 0x28(%%rax)\n\t" \
: \
:"a"(va_wrap_saved_args) \
);
#define VA_WRAP_CALL(func, ret) \
VA_WRAP_CALL_COMMON(); \
va_wrap_saved_args[6] = (uintptr_t)va_wrap_stack; \
asm volatile ( \
"mov (%%rax), %%rsi \n\t" \
"mov 0x8(%%rax), %%rdi \n\t" \
"mov 0x10(%%rax), %%rdx \n\t" \
"mov 0x18(%%rax), %%rcx \n\t" \
"mov 0x20(%%rax), %%r8 \n\t" \
"mov 0x28(%%rax), %%r9 \n\t" \
"mov $0, %%rax \n\t" \
"call *%%rbx \n\t" \
: "=a" (va_wrap_ret) \
: "b" (func), "a" (va_wrap_saved_args) \
: "%rcx", "%rdx", \
"%rsi", "%rdi", "%r8", "%r9", \
"%r10", "%r11", "%r12", "%r14", \
"%r15" \
); \
ret = (typeof(ret)) va_wrap_ret;
#else
/* x86 stdcall */
static inline uintptr_t __attribute__((always_inline))
va_wrap_get_bp()
{
uintptr_t ret;
asm volatile ("mov %%ebp, %0":"=a"(ret));
return ret;
}
#define VA_WRAP_PROLOGUE() \
uintptr_t va_wrap_ret;
#define VA_WRAP_CALL(func, ret) \
VA_WRAP_CALL_COMMON(); \
asm volatile ( \
"mov %2, %%esp \n\t" \
"call *%1 \n\t" \
: "=a"(va_wrap_ret) \
: "r" (func), \
"r"(va_wrap_stack) \
: "%ebx", "%ecx", "%edx" \
); \
ret = (typeof(ret))va_wrap_ret;
#endif
#endif
最後に、次のように呼び出しをラップできます。
int __VA_WRAP_CALL_FUNC wrap_printf(char *str, ...)
{
VA_WRAP_PROLOGUE();
int ret;
VA_WRAP_CALL(printf, ret);
printf("printf returned with %d \n", ret);
return ret;
}
Vfprintfを使用します。
int my_printf(char *fmt, ...) {
va_list va;
int ret;
va_start(va, fmt);
ret = vfprintf(stderr, fmt, va);
va_end(va);
return ret;
}
生のスタック要素を取得できる場所はmy_print()のみであるため、このような関数呼び出しを転送する方法はありません。このような呼び出しをラップする通常の方法は、引数をさまざまなvarargs構造体に変換する関数と、それらの構造体を実際に操作する関数の2つです。このような二重機能モデルを使用すると、（たとえば）printf()の構造体をmy_printf()で初期化してva_start()をラップし、vfprintf()。
はい、できますが、ややsomewhatいため、引数の最大数を知る必要があります。さらに、引数がx86（PowerPCなど）のようなスタックに渡されないアーキテクチャを使用している場合、「特別な」タイプ（double、float、altivecなど）が使用されているかどうか、またしたがって、それに応じて対処してください。すぐに痛みを伴う場合がありますが、x86を使用している場合、または元の機能に明確に定義された制限された境界がある場合は、機能します。 まだハックになります、デバッグ目的で使用します。その周りにソフトウェアを構築しないでください。とにかく、ここにx86での実際の例があります：
#include <stdio.h>
#include <stdarg.h>
int old_variadic_function(int n, ...)
{
va_list args;
int i = 0;
va_start(args, n);
if(i++<n) printf("arg %d is 0x%x\n", i, va_arg(args, int));
if(i++<n) printf("arg %d is %g\n", i, va_arg(args, double));
if(i++<n) printf("arg %d is %g\n", i, va_arg(args, double));
va_end(args);
return n;
}
int old_variadic_function_wrapper(int n, ...)
{
va_list args;
int a1;
int a2;
int a3;
int a4;
int a5;
int a6;
int a7;
int a8;
/* Do some work, possibly with another va_list to access arguments */
/* Work done */
va_start(args, n);
a1 = va_arg(args, int);
a2 = va_arg(args, int);
a3 = va_arg(args, int);
a4 = va_arg(args, int);
a5 = va_arg(args, int);
a6 = va_arg(args, int);
a7 = va_arg(args, int);
va_end(args);
return old_variadic_function(n, a1, a2, a3, a4, a5, a6, a7, a8);
}
int main(void)
{
printf("Call 1: 1, 0x123\n");
old_variadic_function(1, 0x123);
printf("Call 2: 2, 0x456, 1.234\n");
old_variadic_function(2, 0x456, 1.234);
printf("Call 3: 3, 0x456, 4.456, 7.789\n");
old_variadic_function(3, 0x456, 4.456, 7.789);
printf("Wrapped call 1: 1, 0x123\n");
old_variadic_function_wrapper(1, 0x123);
printf("Wrapped call 2: 2, 0x456, 1.234\n");
old_variadic_function_wrapper(2, 0x456, 1.234);
printf("Wrapped call 3: 3, 0x456, 4.456, 7.789\n");
old_variadic_function_wrapper(3, 0x456, 4.456, 7.789);
return 0;
}
何らかの理由で、va_argでfloatを使用することはできません。gccは、floatをdoubleに変換すると言いますが、プログラムはクラッシュします。それだけで、このソリューションがハックであり、一般的なソリューションがないことを示しています。私の例では、引数の最大数は8であると仮定しましたが、その数を増やすことができます。ラップされた関数も整数のみを使用しましたが、常に整数にキャストされるため、他の「通常の」パラメーターでも同じように機能します。ターゲット関数はそれらの型を知っていますが、中間ラッパーは必要ありません。ラッパーは、ターゲット関数もそれを知っているので、正しい数の引数を知る必要はありません。有用な作業を行うには（呼び出しをログに記録するだけではありません）、おそらく両方を知っている必要があります。
話題外の暴言でごめんなさい、しかし：
メタ問題は、Cのvarargsインターフェイスが最初から根本的に壊れていることです。引数リストの終わりは、明示的な終了信号なしで見つけることができないため、バッファオーバーフローと無効なメモリアクセスの誘いです（誰も実際に怠lazを使いません）。そして、それは常に難解な実装固有のマクロに依存しており、重要なva_copy（）マクロはsomeアーキテクチャでのみサポートされていました。
基本的に3つのオプションがあります。
1つは、それを渡すのではなく、ターゲット関数の可変引数実装を使用して、楕円を渡さないことです。もう1つは、可変長マクロを使用することです。 3番目のオプションは、不足しているすべてのものです。
これは本当に扱いやすいと思うので、通常はオプション1を使用します。オプション2には、可変長マクロの呼び出しにいくつかの制限があるため、欠点があります。
コードの例を次に示します。
#include <stdio.h>
#include <stdarg.h>
#define Option_VariadicMacro(f, ...)\
printf("printing using format: %s", f);\
printf(f, __VA_ARGS__)
int Option_ResolveVariadicAndPassOn(const char * f, ... )
{
int r;
va_list args;
printf("printing using format: %s", f);
va_start(args, f);
r = vprintf(f, args);
va_end(args);
return r;
}
void main()
{
const char * f = "%s %s %s\n";
const char * a = "One";
const char * b = "Two";
const char * c = "Three";
printf("---- Normal Print ----\n");
printf(f, a, b, c);
printf("\n");
printf("---- Option_VariadicMacro ----\n");
Option_VariadicMacro(f, a, b, c);
printf("\n");
printf("---- Option_ResolveVariadicAndPassOn ----\n");
Option_ResolveVariadicAndPassOn(f, a, b, c);
printf("\n");
}