When you use a function in C/C++ [or most other programming languages] you are likely to pass it some parameters – data which may be processed by the function or give it information on what action is required. For the majority of programmers, outside of the world of embedded software, parameters are just a fact – no real issues. They are likely to be quite uninterested in how parameters are passed and how efficient and secure that process that might be. Embedded developers tend to want details. Efficient code is essential and avoiding possible bugs is always desirable. So, maybe a look at how parameter passing actually works might be useful …
When embedded systems were all programmed in assembly language, the programmer had complete freedom with parameter passing and a number of options were available:
- Use global variables – not generally recommended, but might be most efficient in some circumstances.
- Use registers – this can be fast and efficient; the required data might already be in a register [which is almost the same as using a global variable, so it needs care].
- Use the stack – SP-relative addressing may be efficient in many processors; this approach leads to reentrant code.
- Use a dedicated memory block – this approach may make sense, if the addressing modes of the processor are limited, but probably results in non-reentrant code.
In C, some aspects of parameter passing are specified by the language definition; others are implementation dependent and may vary from one compiler to another. There are no specific constraints on the parameter passing mechanism. It is left to the compiler writer to choose between stack [which is most common], registers or something else. It is bad programming practice to make assumptions about how parameters are passed. You could write code like this:
void fun(int n)
int *p, x;
p = &n;
x = *++p;
This function simply takes the address of the first parameter, assumes that it is on the stack and indexes off of that address to find further parameters. Please do not do this.
In C/C++ parameters are normally passed by value – the value passed as a parameter is copied into the formal parameter of the function. C++ gives the option of passing by reference, which means that a called function can access variables which are passed as parameters by the calling function. To achieve this in C, you need to use pointers [which is, of course, what C++ is doing behind the scenes].
A small quiz to test your knowledge of C parameter passing: when, in C, is parameter passing by reference the default? Please comment or email. Sorry no prizes, just fame and glory.