8. c16x Backend

8.1 Additional options for this version

This backend provides the following additional options:

`-merge-constants'

Place identical floating point constants at the same memory location. This can reduce program size and increase compilation time.

`-const-in-data'

By default constant data will be placed in a read-only section. Using this option it will be placed in the data section.

`-no-delayed-popping'

By default arguments of function calls are not always popped from the stack immediately after the call, so that the arguments of several calls may be popped at once. With this option vbcc can be forced to pop them after every function call. This may simplify debugging and very slightly reduce the stack size needed by the compiled program.

`-no-peephole'

Do not perform peephole-optimizations.

`-tasking'

Produce output for the Tasking assembler.

`-mtiny'

Assume all functions are within one code-segment. Shorter instructions for calling functions are used and function-pointers will be only 2 bytes long. This results in shorter and faster code.

`-mlarge'

All objects which are not explicitly qualified are assumed to be far (i.e. they may be in different segments but must not cross one segment-boundary). The default pointer size will be 4.

`-mhuge'

All objects which are not explicitly qualified are assumed to be huge (i.e. they may be in different segments and may cross segment-boundaries). The default pointer size will be 4.

`-int32'

Do not use.

8.2 ABI

This backend supports the following registers:

• R0 through R15 for the general purpose registers

Additionally, the register pairs R2/R3, R3/R4, R4/R5, R6/R7, R7/R8, R8/R9, R12/R13, R13/R14, and R15/R15 are available.

R1, R11 and R12 are reserved by the backend.

The current version generates assembly output for use with the vasm assembler. Optionally, assembly code for the Tasking assembler can be generated. The default memory model corresponds to the Tasking small-memory model with 16bit data-pointers and 32bit function-pointers. However, the DPPx registers have to be set up in a way to create a linear 16bit address space (i.e. DPPx=x). The generated code should work on systems with c161, c163, c164, c165 and c167 microcontrollers as well as ST10 derivates. Old versions like the c166 are not supported

The registers R1-R5 and R10-R15 are used as scratch registers (i.e. they can be destroyed in function calls), all other registers are preserved.

R0 is used as user stack pointer. Automatic variables and temporaries are put on the user stack. Return addresses are pushed on the system stack.

The first 4 function arguments which have integer or pointer types are passed in registers R12 through R15.

Integers and pointers are returned in R4/R5. All other types are returned by passing the function the address of the result as a hidden argument - so when you call such a function without a proper declaration in scope you can expect a crash.

The elementary data types are represented like:

type size in bits alignment in bytes char 8 1 short 16 2 int 16 2 long 32 2 long long n/a n/a near pointers 16 2 far pointers 32 2 huge pointers 32 2 float n/a n/a double n/a n/a

8.3 Target-specific variable-attributes

__interrupt

Return with rfi rather than blr. MDL/MDH will be saved, however it is recommended to switch to a new register bank as the gprs are not saved. Also, DPP0-DPP3 are not saved (the compiler does not use them).

__interrupt(<vector>)

Like __interrupt, but also places a jump-instruction to the interrupt service at the corresponding vector table address (needs support from library and linker file).

__section(<name>)

Place this object/function in section <name>.

__rbank(<bank>)

Switch to another register-bank for this function.

8.4 Target-specific type-attributes

__near

Object resides within the same segment.

__far

Object may reside in a different segment, but does not cross a segment-boundary.

__huge

Object may reside in a different segment and may cross a segment-boundary

__section(<name>)

Place this function or object in section <name>.

__sfr(<addr>)

Used to declare a special function register at <addr>.

Example:

__sfr(0xff10) volatile unsigned int PSW;

__esfr(<addr>)

The same for extended special function registers.

__sfrbit(<addr>,<bit>)

Declare a single bit in the bit-addressable area.

Example:

__sfr(0xff10,11) volatile __bit IEN;

__esfrbit(<addr>,<bit>)

The same for the extended bit-addressable area.

8.5 Target-specific types

The c16x-backend offers the following additional types:

__bit

A single bit in the bit-addressable inernal RAM-area. Only static and external variables may use this type. It is not allowed for auto or register storage-class. Also, arrays of bits, pointers to bits or bits within aggregates are not allowed. Conversion of a bit to an integral type yields 0 if the bit is cleared and 1 if it is set.. Conversion of an integral type to a bit clears the bit if the integer is equal to 0 and sets it otherwise.

8.6 Predefined Macros

This backend defines the following macros:

__C16X__

__C167__

__ST10__

8.7 Stack

If the `-stack-check' option is used, every function-prologue will call the function __stack_check with the stacksize needed by this function in register R1. This function has to consider its own stacksize and must restore all registers.

Only stack-checking of the user-stack is supported. Checking the system-stack is supported by hardware.

8.8 Stdarg

A possible <stdarg.h> could look like this:

typedef char *va_list; va_list __va_start(void); #define __va_rounded_size(__TYPE) \ (((sizeof (__TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) #define va_start(__AP,__LA) (__AP=__va_start()) #define va_arg(__AP, __TYPE) \ (__AP = ((char *) (__AP) + __va_rounded_size (__TYPE)), \ *((__TYPE *)((__AP) - __va_rounded_size (__TYPE)))) #define va_end(__AP) ((__AP) = 0)

8.9 Known Problems

• no floating-point
• huge-pointers are sometimes derferenced as far-pointers
• addressing-modes sometimes ignore huge
• initialized data is placed in RAM, bits are not initialized
• struct-copy only works with near-pointers
• near/far-conversion assumes DPP0-DPP3 linear