What does `##` mean in C? - c

Question

This is an excerpt from linux kernel source. What is the stem## usage? seeing for first time in c
#define __pcpu_size_call_return(stem, variable) \
({ typeof(variable) pscr_ret__; \
__verify_pcpu_ptr(&(variable)); \
switch(sizeof(variable)) { \
case 1: pscr_ret__ = stem##1(variable);break; \
case 2: pscr_ret__ = stem##2(variable);break; \
case 4: pscr_ret__ = stem##4(variable);break; \
case 8: pscr_ret__ = stem##8(variable);break; \
default: \
__bad_size_call_parameter();break; \
} \
pscr_ret__; \
})

Answer 1

The preprocessor operator ## provides a way to concatenate actual arguments during macro expansion. If a parameter in the replacement text is adjacent to a ##, the parameter is replaced by the actual argument, the ## and surrounding white space are removed, and the result is re-scanned. For example, the macro paste concatenates its two arguments:
#define paste(front, back) front ## back
so paste(name, 1) creates the token name1.

Answer 2

The ## operator is a preprocessor operation which glues together tokens to form a single token.
So say you want to call two functions based on a common prefix, passing a single argument each time and allowing it to be changed.
You cannot use:
#define CallBoth(pref,arg) \
{ \
arg = pref A (arg); \
arg = pref B (arg); \
}
because the substituted pref and A (or B) will be distinct tokens. Similarly, you cannot use:
#define CallBoth(pref,arg) \
{ \
arg = prefA (arg); \
arg = prefB (arg); \
}
because no substitution of prefA or prefB will take place.
To do this, you use:
#define CallBoth(pref,arg) \
{ \
arg = pref##A(arg); \
arg = pref##B(arg); \
}
and the substituted pref and A (or B) are concatenated into a single token. That way, if you enter:
CallBoth(xyzzy,intVar);
it will be translated to:
{
intVar = xyzzyA(intVar);
intVar = xyzzyB(intVar);
}
Without this feature, there's no way to end up with a single token representing the function name.
As stated in a comment in the file you're referencing:
/* Branching function to split up a function into a set of functions that are called for different scalar sizes of the objects handled. */
So, depending on the size of the variable being given to the macro, it will call one of:
stem1(variable)
stem2(variable)
stem4(variable)
stem8(variable)
where stem and variable are supplied as a parameter to the macro. Or it will call __bad_size_call_parameter() if none of those sizes are relevant.
So, a call:
char char_var;
__pcpu_size_call_return(xyzzy,char_var)
will result in a call:
xyzzy1(char_var):
int int_var;
__pcpu_size_call_return(xyzzy,int_var)
will result in a call:
xyzzy4(int_var)
where sizeof(int) == 4.