8

我的问题vsprintf是我无法直接获取输入参数，我必须先一个一个地获取输入并将它们保存在void**，然后将其传递void**给vsprintf()，这对windows来说很好，但是当我来到64位linux时，gcc无法编译因为它不允许从 to 转换void**，va_list有没有人可以给我一些帮助，我应该如何在 linux 下做到这一点？

我可以在 GCC 中动态创建 va_list 吗？

void getInputArgs(char* str, char* format, ...)
{
    va_list args;
    va_start(args, format);
    vsprintf(str, format, args);
    va_end(args);
}  

void process(void)
{
    char s[256];
    double tempValue;
    char * tempString = NULL;
    void ** args_ptr = NULL;
    ArgFormatType format;   //defined in the lib I used in the code
    int numOfArgs = GetNumInputArgs();  // library func used in my code

    if(numOfArgs>1)
    {
        args_ptr = (void**) malloc(sizeof(char)*(numOfArgs-1));
        for(i=2; i<numOfArgs; i++)
        {
            format = GetArgType();    //library funcs

            switch(format)
            {
                case ArgType_double:
                    CopyInDoubleArg(i, TRUE, &tempValue);   //lib func
                    args_ptr[i-2] = (void*) (int)tempValue;    
                    break;

                case ArgType_char:
                    args_ptr[i-2]=NULL;
                    AllocInCharArg(i, TRUE, &tempString);  //lib func
                    args_ptr[i-2]= tempString;
                break;
            }
        }
    }

    getInputArgs(s, formatString, (va_list) args_ptr);   //Here 
           // is the location where gcc cannot compile, 
           // Can I and how if I can create a va_list myself?
}
4

5 回答 5

6

有一种方法可以做到这一点，但它特定于gccLinux。它确实适用于 32 位和 64 位版本的 Linux（已测试）。

免责声明：我不支持使用此代码。它不便携，很老套，坦率地说，它是众所周知的钢丝绳上的一头不稳定平衡的大象。我只是在证明可以动态创建va_listusing gcc，这就是原始问题所要问的。

话虽如此，以下文章详细介绍va_list了 amd64 ABI 的工作原理：Amd64 和 Va_arg。

了解结构的内部结构后va_list，我们可以欺骗宏从我们自己构建va_arg的 a 中读取：va_list

#if (defined( __linux__) && defined(__x86_64__))
// AMD64 byte-aligns elements to 8 bytes
#define VLIST_CHUNK_SIZE 8
#else
#define VLIST_CHUNK_SIZE 4
#define _va_list_ptr _va_list
#endif

typedef struct  {
    va_list _va_list;
#if (defined( __linux__) && defined(__x86_64__))
    void* _va_list_ptr;
#endif
} my_va_list;

void my_va_start(my_va_list* args, void* arg_list)
{
#if (defined(__linux__) && defined(__x86_64__))
    /* va_args will read from the overflow area if the gp_offset
       is greater than or equal to 48 (6 gp registers * 8 bytes/register)
       and the fp_offset is greater than or equal to 304 (gp_offset +
       16 fp registers * 16 bytes/register) */
    args->_va_list[0].gp_offset = 48;
    args->_va_list[0].fp_offset = 304;
    args->_va_list[0].reg_save_area = NULL;
    args->_va_list[0].overflow_arg_area = arg_list;
#endif
    args->_va_list_ptr = arg_list;
}

void my_va_end(my_va_list* args)
{
    free(args->_va_list_ptr);
}

typedef struct {
    ArgFormatType type; // OP defined this enum for format
    union {
        int i;
        // OTHER TYPES HERE
        void* p;
    } data;
} va_data;

现在，我们可以va_list使用类似您的process()方法或以下内容生成指针（对于 64 位和 32 位版本都是相同的）：

void* create_arg_pointer(va_data* arguments, unsigned int num_args) {
    int i, arg_list_size = 0;
    void* arg_list = NULL;

    for (i=0; i < num_args; ++i)
    {
        unsigned int native_data_size, padded_size;
        void *native_data, *vdata;

        switch(arguments[i].type)
        {
            case ArgType_int:
                native_data = &(arguments[i].data.i);
                native_data_size = sizeof(arguments[i]->data.i);
                break;
            // OTHER TYPES HERE
            case ArgType_string:
                native_data = &(arguments[i].data.p);
                native_data_size = sizeof(arguments[i]->data.p);
                break;
            default:
                // error handling
                continue;
        }

        // if needed, pad the size we will use for the argument in the va_list
        for (padded_size = native_data_size; 0 != padded_size % VLIST_CHUNK_SIZE; padded_size++);

        // reallocate more memory for the additional argument
        arg_list = (char*)realloc(arg_list, arg_list_size + padded_size);

        // save a pointer to the beginning of the free space for this argument
        vdata = &(((char *)(arg_list))[arg_list_size]);

        // increment the amount of allocated space (to provide the correct offset and size for next time)
        arg_list_size += padded_size;

        // set full padded length to 0 and copy the actual data into the location
        memset(vdata, 0, padded_size);
        memcpy(vdata, native_data, native_data_size);
    }

    return arg_list;
}

最后，我们可以使用它：

va_data data_args[2];
data_args[0].type = ArgType_int;
data_args[0].data.i = 42;

data_args[1].type = ArgType_string;
data_args[1].data.p = "hello world";

my_va_list args;
my_va_start(&args, create_arg_pointer(data_args, 2));

vprintf("format string %d %s", args._va_list);

my_va_end(&args);

你有它。它的工作方式与普通和宏基本相同，但允许您传递自己动态生成的字节对齐指针以供使用，而不是依赖调用约定来设置堆栈帧。va_startva_end

于 2015-06-03T23:45:35.217 回答
3

我尝试过使用其他地方提到的 libffi，它可以工作。下面是链接，希望对遇到类似问题的人有所帮助。再次感谢我在这里得到的所有帮助！

链接： http: //www.atmark-techno.com/~yashi/libffi.html -- 给出的简单示例 http://www.swig.org/Doc1.3/Varargs.html -- printf() 和其他示例给定

于 2012-07-31T13:05:52.550 回答
2

类型va_list不是void **或与 64 位类似gcc（在 Intel x86/64 机器上）。在 Mac OS X 10.7.4 和 RHEL 5 上stdarg.h，/usr/include. 考虑以下代码：

#include <stdarg.h>
#include <stdio.h>
int main(void)
{
    printf("sizeof(va_list) = %zu\n", sizeof(va_list));
    return 0;
}

使用 64 位编译的 RHEL 5 和 Mac OS X 10.7 上的输出为：

sizeof(va_list) = 24

使用 32 位编译，每个平台上的输出为：

sizeof(va_list) = 4

（您可能会认为我很惊讶地发现 32 位和 64 位版本之间存在如此大的差异。我期望 32 位版本的值介于 12 和 24 之间。）

所以，类型是不透明的；你甚至找不到能告诉你任何信息的标题；它比 64 位机器上的单个指针大得多。

即使您的代码在某些机器上工作，它也远不能保证在任何地方都能工作。

GCC 4.7.1 手册没有提到任何允许您va_list在运行时构建的函数。

于 2012-07-27T23:31:35.480 回答
0

以下课程对我有用：

class VaList
{
    va_list     _arguments;

public:

    explicit inline VaList(const void * pDummy, ...)
    {
        va_start(_arguments, pDummy);
    }

    inline operator va_list &()
    {
        return _arguments;
    }

    inline operator const va_list &() const
    {
        return _arguments;
    }

    inline ~VaList()
    {
        va_end(_arguments);
    }
};

它可以像这样使用：

void v(const char * format, const va_list & arguments)
{
    vprintf(format, const_cast<va_list &>(arguments));
}

...

    v("%d\n", VaList("", 1)); // Uses VaList::operator va_list &()
    v("%d %d\n", VaList(nullptr, 2, 3)); // Uses VaList::operator va_list &()
    vprintf("%s %s %s\n", VaList("", "Works", "here", "too!"));

    const VaList args(NULL, 4, 5, "howdy", "there");
    v("%d %d %s %s\n", args); // Uses VaList::operator const va_list &() const

第一个虚拟参数可以是任何类型的指针，它仅用于计算以下参数的地址。

当然，同样可以在 C 中完成，但不是那么漂亮（使用指针而不是引用）！

使用 VaList 构造动态 va_list 的简单示例：

static void VectorToVaList(const std::vector<int> & v, va_list & t)
{
    switch (v.size())
    {
        case 1: va_copy(t, VaList("", v[0])); return;
        case 2: va_copy(t, VaList("", v[0], v[1])); return;
        case 3: va_copy(t, VaList("", v[0], v[1], v[2])); return;
        case 4: va_copy(t, VaList("", v[0], v[1], v[2], v[3])); return;
        // etc
    }

    throw std::out_of_range("Out of range vector size!");
}

和用法：

    va_list t;
    VectorToVaList(std::vector<int>{ 1, 2, 3, 4 }, t);
    vprintf("%d %d %d %d\n", t);
于 2018-08-15T07:39:34.307 回答
-1

如果您要解决的问题是以va_list样式插入传递任意类型到函数，那么请考虑使用union：

#include <iostream>
#include <cstdarg>

union ARG
{
    int d;
    char* s;
    double f;
};

int main()
{
    printf("%d %s %f \n", 1, "two", 3.1415 );
    // Output: 1 two 3.141500

    char format[ 1024 ] = "%d %s %f\n";
    ARG args[ 5 ] = { };
    args[ 0 ].d = 1;
    args[ 1 ].s = "two";
    args[ 2 ].f = 3.1415;
    printf( format, args[ 0 ], args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ] );
    // Output: 1 two 3.141500

    return 0;
}

关于我的解决方案，你会注意到一些事情：

  • 没有尝试产生正确数量的参数。即我提供了过多的参数，但是，大多数函数会查看第一个参数来确定如何处理其余的（即格式）
  • 我没有费心动态地创建格式，但是，构建一个动态填充format和args.

对此进行了测试： - Ubuntu，g++ - Android NDK

我做了一些更多的测试，并确认了@PeterCoordes 关于这个答案的评论不适用于双精度。

于 2019-12-02T15:59:09.543 回答