va_arg() problem

ntubski · 08-25-2014, 12:24 PM

Quote:

Originally Posted by doughyi8u

I must be missing something b/c I thought that s would get one string out of the argv parameter passed in to the function as a va_arg.

It gets one argument out the arguments you passed to the function, which is argv (not argv's contents) in this case.

NevemTeve · 08-25-2014, 01:28 PM

Code:

static void testfun (const char *fmt, ...)
{
   const char *p= fmt-1;
   va_list ap;
   int n;
   const char *s;

   va_start (ap, fmt);

   while (*++p) {
      switch (*p) {
      case 'd':
          n= va_arg (ap, int);
          printf ("integer param: %d\n", n);
          break;
      case 's':
          s= va_arg(ap, char *);
          printf ("string param: %s\n", s);
          break;
      default:
          printf ("*** unimplemented '%c'\n", *p);
          break;
      }
   }
   va_end(ap);
}

int main (void)
{
    testfun ("sds", "param1str", 2, "param3str");
    return 0;
}

a4z · 08-26-2014, 06:09 AM

Quote:

Originally Posted by doughyi8u

I'm trying to grasp va_arg

great, and when you are done start with
why C++ does not need C style va_args,
and
why you should run away when you see someone using them

mina86 · 08-26-2014, 09:46 AM

Quote:

Originally Posted by NevemTeve

Code:

/* works on x86, doesn't work on x86-64 */

This is because the x86_64 ABI uses registers to pass the first few arguments even for ... functions.

NevemTeve · 08-26-2014, 10:07 AM

off-topic, but here is the definition of va_list on x86_64:

Code:

typedef struct __va_list_tag {
    unsigned int gp_offset;
    unsigned int fp_offset;
    void *overflow_arg_area;
    void *reg_save_area;
} va_list[1];

It being a typedef-ed array in x86-64, and pointer in other platforms; sometime it is hard to create platform independent code if you have to pass va_list between function. My little hack:

Code:

typedef struct va_list_struct {
    va_list ap;>/* platform_dependent: pointer _or_ array */
} va_list_struct;
...

void function2 (va_list_struct *myap);

void function1_v (va_list ap)
{
    va_list_struct myap;
    va_copy (myap.ap, ap);
    function2 (&myap);
    va_end (myap.ap);
}

void function1_f (int lastfixed, ...)
{
    va_list_struct myap;

    va_start (myap.ap, lastfixed);
    function2 (&myap);
    va_end (myap.ap);
}

void function2 (va_list_struct *myap)
{
    sometype x;

    x= va_arg (myap->ap, sometype);
}

mina86 · 08-26-2014, 11:51 AM

Uh? I don't understand why you need that. You can just pass va_list directly by value and since it's an array, pointer to its first argument will be the value passed.

NevemTeve · 08-26-2014, 12:30 PM

Well, you are right, it would compile and run; the problem arises when both functions (caller and callee) wishes to fetch from the same va_list: the result will be different in x86 ('ap' is a pointer that is copied when passed as parameter) and in x86-64 ('ap' is an array, it's address is passed as parameter). If you would want to pass 'va_list *' instead to fix this, you would get compilation problems in 64-bit mode.

Code:

/* va3264.c */

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void function2 (va_list ap);

static void function1 (va_list ap)
{
    int x;

    function2 (ap);
    x= va_arg (ap, int);
    printf ("function1: int arg=%d\n", x);

    function2 (ap);
    x= va_arg (ap, int);
    printf ("function1: int arg=%d\n", x);
}

static void function2 (va_list ap)
{
    int x;

    x= va_arg (ap, int);
    printf ("function2: int arg=%d\n", x);
}

void function_f (int lastfixed, ...)
{
    va_list ap;

    va_start (ap, lastfixed);
    function1 (ap);
    va_end (ap);
}

int main (void)
{
    function_f (9999, 1, 2, 3, 4, 5);

    return 0;
}

Results:

Code:

$ ./va32
function2: int arg=1
function1: int arg=1
function2: int arg=2
function1: int arg=2

$ ./va64
function2: int arg=1
function1: int arg=2
function2: int arg=3
function1: int arg=4

mina86 · 08-26-2014, 05:28 PM

Quote:

Originally Posted by NevemTeve

Well, you are right, it would compile and run; the problem arises when both functions (caller and callee) wishes to fetch from the same va_list: the result will be different in x86 ('ap' is a pointer that is copied when passed as parameter) and in x86-64 ('ap' is an array, it's address is passed as parameter). If you would want to pass 'va_list *' instead to fix this, you would get compilation problems in 64-bit mode.

That's what va_copy is for.

NevemTeve · 08-26-2014, 11:59 PM

There is a thing va_copy is good for: ensure the behaviour I presented with 'va32': create an independent copy of 'ap' so that both instances of it could be read independently.
But if you want the other behaviour (presented with 'va64'), i.e. both function read from the same argument-list, it doesn't help.

Example for such usage:

Code:

int vsprintf (char *to, const char *fmt, va_list ap)
{
   char *p= to;
...
   case 'd':
        p += vsprintf_int (p, fmtopts, ap); break; 
        /* depending on fmtopts, reads 1 or 2 arguments from 'ap' */

   case 's':
        p += vsprintf_str (p, fmtopts, ap); break; 
        /* depending on fmtopts, reads 1,2 or 3 arguments from 'ap' */
...
   return (int)(p-to);
}

PS: Most likely I have already heard of 'va_copy', because I did use it in my post #20.

mina86 · 08-27-2014, 07:20 AM

If you want functions to use the same argument list you just pass the va_list argument. I'm just confused about what you're trying to accomplish that cannot be done with va_copy ore passing va_list around:

Code:

#include <stdarg.h>
#include <stdio.h>

static void f(unsigned n, va_list ap) {
	printf("f: %d: %s\n", n, va_arg(ap, const char *));
}

static void g(unsigned n, va_list ap) {
	va_list ap2;
	va_copy(ap2, ap);
	printf("g: %d: %s\n", n, va_arg(ap2, const char *));
	va_end(ap2);
}

static void func(unsigned n, ...) {
	unsigned i;
	va_list ap;

	va_start(ap, n);
	for (i = 0; i < n; ++i) {
		if (i % 2)
			g(i, ap);
		f(i, ap);
	}
	va_end(ap);
}

int main(void) {
	func(4, "foo", "bar", "baz", "qux");
	return 0;
}

Code:

f: 0: foo
g: 1: bar
f: 1: bar
f: 2: baz
g: 3: qux
f: 3: qux

NevemTeve · 08-27-2014, 07:35 AM

You didn't test this in 32-bit mode, did you?

Code:

$ ./mina32
f: 0: foo
g: 1: foo
f: 1: foo
f: 2: foo
g: 3: foo
f: 3: foo

$ ./mina64
f: 0: foo
g: 1: bar
f: 1: bar
f: 2: baz
g: 3: qux
f: 3: qux

mina86 · 08-27-2014, 07:52 AM

Ah, now I see, thanks. That's interesting and disturbing at the same time.

NevemTeve · 08-27-2014, 08:02 AM

Off-topic of off-topic: There was a similar (a little bit similar) problem in OpenSsl's DES functionality:
older version typedefed array 'des_key_schedule',
newer version typedefed struct 'DES_key_schedule', and for compatility also struct 'des_key_schedule'.

I had to pass 'des_key_schedule' between functions, so I couldn't create a version that compiled without warnings with both OpenSsl versions. My only idea to maintain compatibility was this:

Code:

typedef struct DKS {
    des_key_schedule dks;
} DKS;
void myfun (DKS *dks);

NevemTeve · 11-22-2017, 10:12 AM

I know it's late, but it is related: when passing a 'va_list' as a variadic function-parameter (which is rare, I admit), va_copy isn't our friend (at least with AMD64/Linux/gcc|clang)

Code:

/* stdarg_test.c */

#include <stdarg.h>
#include <stdio.h>
#include <string.h>

static void testfun (int nfun, ...)
{
    const char *fmt;
    va_list input_argptr;
    int i;

    va_start (input_argptr, nfun);
    for (i=0; i<nfun; ++i) {
        const char *funname= va_arg (input_argptr, const char *);

        if (strcmp (funname, "fputs")==0) {
            const char *msg= va_arg (input_argptr, const char *);
            fputs (msg, stdout);

        } else if (strcmp (funname, "sprintf")==0) {
            char buff [512];
#ifdef I_WANT_SEGFAULT_WITH_64BIT_LINUX
            va_list passed_argptr;

            fmt= va_arg (input_argptr, const char *);
            va_copy (passed_argptr, va_arg (input_argptr, va_list)); /* DOESN'T REALLY WORK */
            vsnprintf (buff, sizeof buff, fmt, passed_argptr);
#else
            void *passed_argptr;
            fmt= va_arg (input_argptr, void *);
            passed_argptr= va_arg (input_argptr, void *);
            vsnprintf (buff, sizeof buff, fmt, passed_argptr);
#endif
            fputs (buff, stdout);
        }
    }
}

static void middle (const char *fmt, ...)
{
    va_list passed_argptr;

    va_start (passed_argptr, fmt);
    testfun (3,
             "fputs", "start\n",
             "sprintf", fmt, passed_argptr,
             "fputs", "end\n"
             );
}

int main (int argc, const char **argv)
{
    middle ("argv[0]=%s argc=%d\n", argv[0], argc);
}