Function Declarations

The Cx51 compiler provides a number of extensions for standard C function declarations. These extensions allow you to:

Descriptions of these attributes and other features are described in detail in the following sections.

Function Parameters and the Stack

The stack pointer on the classic 8051 accesses internal data memory only. The Cx51 compiler locates the stack area immediately following all variables in the internal data memory. The stack pointer accesses internal memory indirectly and can use all of the internal data memory up to the 0xFF limit.

The total stack space of the classic 8051 is limited: only 256 bytes maximum. Rather than consume stack space with function parameters or arguments, The Cx51 compiler assigns a fixed memory location for each function parameter.

When a function is called, the caller must copy the arguments into the assigned memory locations before transferring control to the desired function. The

function then extracts its parameters, as needed, from these fixed memory 3 locations. Only the return address is stored on the stack during this process.

Interrupt functions require more stack space because they must switch register banks and save the values of a few registers on the stack.

NOTE

The Cx51 compiler uses extended stack areas that are available in some enhanced 8051 variants. In this way the stack space can be increased to several KiloBytes.

By default, the Cx51 compiler passes up to three function arguments in registers. This enhances speed performance. For more information, refer to “Passing Parameters in Registers” on page 120.

NOTE

Some 8051 derivatives provide only 64 bytes of on-chip data memory; most devices have just 256 bytes. Take this into consideration when determining which memory model to use, because the amount of on-chip data and idata memory used directly affects the amount of stack space.

Passing Parameters in Registers

The Cx51 compiler allows up to three function arguments to be passed in CPU registers. This mechanism significantly improves system performance as arguments do not have to be written to and read from memory. Argument or parameter passing can be controlled by the REGPARMS and NOREGPARMS control directives defined in the previous chapter.

The following table details the registers used for different argument positions and data types.

If no registers are available for argument passing, fixed memory locations are used for function parameters.

Function Return Values

CPU registers are always used for function return values. The following table lists the return types and the registers used for each.

NOTE

If the first parameter of a function is a bit type, then other parameters are not passed in registers. This is because parameters that are passed in registers are out of sequence with the numbering scheme shown above. For this reason, bit parameters should be declared at the end of the argument list.

Specifying the Memory Model for a Function

A function’s arguments and local variables are stored in the default memory space specified by the memory model. Refer to “Memory Models” on page 94 for more information.

You may, however, specify which memory model to use for a single function by including the small, compact, or large function attribute in the function declaration. For example:

extern int calc (char i, int b) large reentrant;

extern int func (int i, float f) large; 3 extern void *tcp (char xdata *xp, int ndx) small;

int mtest (int i, int y) /* Small model */

{

return (i * y + y * i + func(-1, 4.75));

}

int large_func (int i, int k) large /* Large model */

{

return (mtest (i, k) + 2);

}

The advantage of functions using the SMALL memory model is that the local data and function argument parameters are stored in the internal 8051 RAM. Therefore, data access is very efficient. The internal memory is limited. Occasionally, the small model cannot satisfy the requirements of a very large program and other memory models must be used. For this situation, you may declare that a function use a different memory model, as shown above.

By specifying the function model attribute in the function declaration, you can select which of the three possible reentrant stacks and frame pointers to use. Stack access in the SMALL model is more efficient than in the LARGE model.