If you're using GCC, and willing to use its language extensions, you can accomplish what you're trying to do with a transparent_union.

From https://gcc.gnu.org/onlinedocs/gcc-3.1/gcc/Type-Attributes.html:

Transparent unions are designed for library functions that have multiple interfaces for compatibility reasons. For example, suppose the wait function must accept either a value of type int * to comply with Posix, or a value of type union wait * to comply with the 4.1BSD interface. If wait's parameter were void *, wait would accept both kinds of arguments, but it would also accept any other pointer type and this would make argument type checking less useful. Instead, might define the interface as follows:

      typedef union
        {
          int *__ip;
          union wait *__up;
        } wait_status_ptr_t __attribute__ ((__transparent_union__));

      pid_t wait (wait_status_ptr_t);

In your example, you'd declare union_attribute like this:

typedef union {
    struct complex_attribute *complex;
    struct generic_attribute *generic;
} union_attribute __attribute__ ((__transparent_union__));

And then you can call prepare_tagged_attribute exactly how you proposed.

struct tagged_attribute* prepare_tagged_attribute(int code, union_attribute attribute)
{
   attribute.generic_attribute->current_value = 1; // e.g.
   return NULL; // e.g.
}

prepare_tagged_attribute(code, pointer_to_complex_structure);

Since there is no polymorphism or overloading in C, I'm not sure there's a perfect solution to this.

Your solution will work, provided that you wrap up your pointer in a union_attribute:

union union_attribute argument;
argument.complex = pointer_to_complex_structure;
prepare_tagged_attribute(2, &argument);

It's a bit annoying that you have to do this wrap, so one option would be to introduce a new function to do it for you:

union union_attribute wrap_complex(struct complex_attribute* attr) {
    union union_attribute result;
    result.complex = attr;
    return result;
}

Then, rewrite your prepare_tagged_attribute function to take in a union by value rather than by pointer:

struct tagged_attribute* prepare_tagged_attribute(int code, union union_attribute attribute)

Then, you can say something like

prepare_tagged_attribute(2, wrap_complex(pointer_to_complex_structure));

It's not perfect, for sure, but it works and type-checks.

Hope this helps!

As you declared the function to take a union argument, you do have to actually pass a union argument, not a pointer.

Sidenote: If using gcc, have a look at the transparent_union attribute. That might be interesting for you, as it actually allows the usage above. Note, howeer, you still have to signal which type of argument you are passing (as much as for the standard way.

A possibly better way would be to bundle type and value information in a single struct like:

struct variable_argument {
    enum {
        COMPLEX_ARG, GENERIC_ARG
    } type;
    union union_attribute{
        struct complex_attribute *complex;
        struct generic_attribute *generic;
    };
};

and pass a pointer to such a struct to the function. Note I uses an anonymous struct field for the union (since C99). This way you can refer the fields like:

struct variable_argument s;

... s.complex = ...

Never forget to set s.type appropriately if you change the type of the union, however.

This struct actually relaces your pointers to one of the other structures. However, you might have them directly in the union instead of using pointers. That simplifies memory allocation/freeing.