sdcc - Online in the Cloud

PROGRAM:

NAME

sdcc - Small Device C Compiler

SYNOPSIS

sdcc [options] filename

WARNING

The information in this man page is an extract from the full documentation of SDCC, and is
limited to the meaning of the options.

For complete and current documentation, refer to the SDCC Compiler User Guide.

DESCRIPTION

SDCC is free open source, retargettable, optimizing ANSI-C compiler designed for 8 bit
Microprocessors. The current version targets Intel MCS51 based Microprocessors (8031,
8032, 8051, 8052, etc.), Dallas DS80C390 variants, Freescale (formerly Motorola) HC08 and
Zilog Z80 based MCUs (z80, z180, gbz80, Rabbit 2000/3000). It can be retargeted for other
microprocessors, support for Microchip PIC is under development.

SDCC uses a modified version of ASXXXX & ASLINK, free open source retargetable assembler &
linker.

SDCC has extensive language extensions suitable for utilizing various microcontrollers and
underlying hardware effectively.

SDCC uses ASXXXX & ASLINK, a Freeware, retargettable assembler & linker. SDCC has
extensive language extensions suitable for utilizing various microcontrollers and
underlying hardware effectively.

The compiler also allows inline assembler code to be embedded anywhere in a function. In
addition, routines developed in assembly can also be called.

PROCESSOR SELECTION OPTIONS

-mmcs51
Generate code for the MCS51 (8051) family of processors. This is the default
processor target.

-mds390
Generate code for the DS80C390 processor.

-mds400
Generate code for the DS80C400 processor.

-mz80 Generate code for the Z80 family of processors.

-mhc08 Generate code for the GameBoy Z80 processor.

-mz80 Generate code for the Zilog Z80 family of processors.

-mz180 Generate code for the Zilog Z180 family of processors.

-mr2k Generate code for the Rabbit 2000 / Rabbit 3000 family of processors."

-mr3ka Generate code for the Rabbit 2000 / Rabbit 3000 family of processors. Check XXXXX"

-mgbz80
Generate code for the GameBoy Z80 processor (Not actively maintained).

-mpic14
Generate code for the Microchip PIC 14-bit processors (p16f84 and variants. In
development, not complete).

-mpic16
Generate code for the Microchip PIC 16-bit processors (p18f452 and variants. In
development, not complete).

-mtlcs900h
Generate code for the Toshiba TLCS-900H processor (Not maintained, not complete).

-mxa51 Generate code for the Phillips XA51 processor (Not maintained, not complete).

-mstm8 Generate code for the STM8 processor.

PREPROCESSOR OPTIONS

-I<path>
The additional location where the pre processor will look for `<..h>' or `..h'
files.

-D <macro[=value]>
Command line definition of macros. Passed to the pre processor.

-M Tell the preprocessor to output a rule suitable for make describing the
dependencies of each object file. For each source file, the preprocessor outputs
one make-rule whose target is the object file name for that source file and whose
dependencies are all the files `#include'd in it. This rule may be a single line or
may be continued with `\'-newline if it is long. The list of rules is printed on
standard output instead of the preprocessed C program. `-M' implies `-E'.

-C Tell the preprocessor not to discard comments. Used with the `-E' option.

-MM Like `-M' but the output mentions only the user header files included with
`#include "file"'. System header files included with `#include <file>' are omitted.

-A question(answer)
Assert the answer answer for question, in case it is tested with a preprocessor
conditional such as `#if #question(answer)'. `-A-' disables the standard
assertions that normally describe the target machine.

-A question
(answer) Assert the answer answer for question, in case it is tested with a
preprocessor conditional such as `#if #question(answer)'. `-A-' disables the
standard assertions that normally describe the target machine.

-Umacro
Undefine macro macro. `-U' options are evaluated after all `-D' options, but
before any `-include' and `-imacros' options.

-dM Tell the preprocessor to output only a list of the macro definitions that are in
effect at the end of preprocessing. Used with the '-E' option.

-dD Tell the preprocessor to pass all macro definitions into the output, in their
proper sequence in the rest of the output.

-dN Like `-dD'except that the macro arguments and contents are omitted. Only `#define
name' is included in the output.

LINKER OPTIONS

-L, -lib-path<absolute path to additional libraries>
This option is passed to the linkage editor's additional libraries search path. The
path name must be absolute. Additional library files may be specified in the
command line. See section Compiling programs for more details.

--xram-loc <Value>
The start location of the external ram, default value is 0. The value entered can
be in Hexadecimal or Decimal format, e.g.: --xram-loc 0x8000 or --xram-loc 32768.

--code-loc <Value>
The start location of the code segment, default value 0. Note when this option is
used the interrupt vector table is also relocated to the given address. The value
entered can be in Hexadecimal or Decimal format, e.g.: --code-loc 0x8000 or --code-
loc 32768.

--stack-loc <Value>
The initial value of the stack pointer. The default value of the stack pointer is
0x07 if only register bank 0 is used, if other register banks are used then the
stack pointer is initialized to the location above the highest register bank used.
eg. if register banks 1 & 2 are used the stack pointer will default to location
0x18. The value entered can be in Hexadecimal or Decimal format, eg. --stack-loc
0x20 or --stack-loc 32. If all four register banks are used the stack will be
placed after the data segment (equivalent to --stack-after-data)

--stack-after-data
This option will cause the stack to be located in the internal ram after the data
segment.

--data-loc <Value>
The start location of the internal ram data segment, the default value is 0x30. The
value entered can be in Hexadecimal or Decimal format, eg. --data-loc 0x20 or
--data-loc 32.

--idata-loc <Value>
The start location of the indirectly addressable internal ram, default value is
0x80. The value entered can be in Hexadecimal or Decimal format, eg. --idata-loc
0x88 or --idata-loc 136.

--out-fmt-ihx
The linker output (final object code) is in Intel Hex format. (This is the default
option).

--out-fmt-s19
The linker output (final object code) is in Motorola S19 format.

MCS51 OPTIONS

--model-large
Generate code for Large model programs see section Memory Models for more details.
If this option is used all source files in the project should be compiled with this
option. In addition the standard library routines are compiled with small model,
they will need to be recompiled.

--model-small
Generate code for Small Model programs see section Memory Models for more details.
This is the default model.

DS390 / DS400 OPTIONS

--model-flat24
Generate 24-bit flat mode code. This is the one and only that the ds390 code
generator supports right now and is default when using -mds390.

--protect-sp-update
Disable interrupts during ESP:SP updates.

_--stack-10bit
Generate code for the 10 bit stack mode of the Dallas DS80C390 part. This is the
one and only that the ds390 code generator supports right now and is default when
using -mds390. In this mode, the stack is located in the lower 1K of the internal
RAM, which is mapped to 0x400000 . Note that the support is incomplete, since it
still uses a single byte as the stack pointer. This means that only the lower 256
bytes of the potential 1K stack space will actually be used. However, this does
allow you to reclaim the precious 256 bytes of low RAM for use for the DATA and
IDATA segments. The compiler will not generate any code to put the processor into
10 bit stack mode. It is important to ensure that the processor is in this mode
before calling any re-entrant functions compiled with this option. In principle,
this should work with the --stack-auto option, but that has not been tested. It is
incompatible with the --xstack option. It also only makes sense if the processor is
in 24 bit contiguous addressing mode (see the --model-flat24 option).

Z80 Options

--callee-saves-bc
Force a called function to always save BC.

--no-std-crt0
When linking, skip the standard crt0.o object file. You must provide your own
crt0.o for your system when linking.

OPTIMIZATIONS OPTIONS

--nogcse
Will not do global subexpression elimination, this option may be used when the
compiler creates undesirably large stack/data spaces to store compiler temporaries.
A warning message will be generated when this happens and the compiler will
indicate the number of extra bytes it allocated. It recommended that this option
NOT be used, #pragma NOGCSE can be used to turn off global subexpression
elimination for a given function only.

--noinvariant
Will not do loop invariant optimizations, this may be turned off for reasons
explained for the previous option. For more details of loop optimizations performed
see section Loop Invariants.It recommended that this option NOT be used, #pragma
NOINVARIANT can be used to turn off invariant optimizations for a given function
only.

--noinduction
Will not do loop induction optimizations, see section strength reduction for more
details. It is recommended that this option is NOT used, #pragma NOINDUCTION can be
used to turn off induction optimizations for a given function only.

--nojtbound
Will not generate boundary condition check when switch statements are implemented
using jump-tables. It is recommended that this option is NOT used, #pragma
NOJTBOUND can be used to turn off boundary checking for jump tables for a given
function only.

--noloopreverse
Will not do loop reversal optimization.

OTHER OPTIONS

-c, --compile-only
will compile and assemble the source, but will not call the linkage editor.

-E Run only the C preprocessor. Preprocess all the C source files specified and output
the results to standard output.

--stack-auto
All functions in the source file will be compiled as reentrant, i.e. the parameters
and local variables will be allocated on the stack. If this option is used all
source files in the project should be compiled with this option.

--xstack
Uses a pseudo stack in the first 256 bytes in the external ram for allocating
variables and passing parameters.

--callee-saves function1[,function2][,function3]....
The compiler by default uses a caller saves convention for register saving across
function calls, however this can cause unnecessary register pushing & popping when
calling small functions from larger functions. This option can be used to switch
the register saving convention for the function names specified. The compiler will
not save registers when calling these functions, no extra code will be generated at
the entry & exit for these functions to save & restore the registers used by these
functions, this can SUBSTANTIALLY reduce code & improve run time performance of the
generated code. In the future the compiler (with interprocedural analysis) will be
able to determine the appropriate scheme to use for each function call. DO NOT use
this option for built-in functions such as _muluint..., if this option is used for
a library function the appropriate library function needs to be recompiled with the
same option. If the project consists of multiple source files then all the source
file should be compiled with the same --callee-saves option string.

--debug
When this option is used the compiler will generate debug information, that can be
used with the SDCDB. The debug information is collected in a file with .cdb
extension.

--regextend
This option is obsolete and isn't supported anymore.

--noregparms
This option is obsolete and isn't supported anymore.

--peep-file<filename>
This option can be used to use additional rules to be used by the peep hole
optimizer.

-S Stop after the stage of compilation proper; do not assemble. The output is an
assembler code file for the input file specified.

-Wa_asmOption[,asmOption]...]
Pass the asmOption to the assembler.

-Wl_linkOption[,linkOption]...]
Pass the linkOption to the linker.

--int-long-reent
Integer (16 bit) and long (32 bit) libraries have been compiled as reentrant. Note
by default these libraries are compiled as non-reentrant.

--cyclomatic
This option will cause the compiler to generate an information message for each
function in the source file. The message contains some important information about
the function. The number of edges and nodes the compiler detected in the control
flow graph of the function, and most importantly the cyclomatic complexity.

--float-reent
Floating point library is compiled as reentrant.

--nooverlay
The compiler will not overlay parameters and local variables of any function, see
section Parameters and local variables for more details.

--main-return
This option can be used when the code generated is called by a monitor program.
The compiler will generate a 'ret' upon return from the 'main' function. The
default option is to lock up i.e. generate a 'ljmp '.

--no-peep
Disable peep-hole optimization.

--peep-asm
Pass the inline assembler code through the peep hole optimizer. This can cause
unexpected changes to inline assembler code, please go through the peephole
optimizer rules defined in the source file tree '<target>/peeph.def' before using
this option.

--iram-size <Value>
Causes the linker to check if the interal ram usage is within limits of the given
value.

--nostdincl
This will prevent the compiler from passing on the default include path to the
preprocessor.

--nostdlib
This will prevent the compiler from passing on the default library path to the
linker.

--verbose
Shows the various actions the compiler is performing.

-V Shows the actual commands the compiler is executing.

INTERMEDIATE DUMP OPTIONS

The following options are provided for the purpose of retargetting and debugging the
compiler. These provided a means to dump the intermediate code (iCode) generated by the
compiler in human readable form at various stages of the compilation process.

--dumpraw
This option will cause the compiler to dump the intermediate code into a file of
named <source filename>. dumpraw just after the intermediate code has been
generated for a function, i.e. before any optimizations are done. The basic blocks
at this stage ordered in the depth first number, so they may not be in sequence of
execution.

--dumpgcse
Will create a dump of iCode's, after global subexpression elimination, into a file
named <source filename>.dumpgcse.

--dumpdeadcode
Will create a dump of iCode's, after deadcode elimination, into a file named
<source filename>.dumpdeadcode.

--dumploop
Will create a dump of iCode's, after loop optimizations, into a file named <source
filename>.dumploop.

--dumprange
Will create a dump of iCode's, after live range analysis, into a file named <source
filename>.dumprange.

--dumlrange
Will dump the life ranges for all symbols.

--dumpregassign
Will create a dump of iCode's, after register assignment, into a file named <source
filename>.dumprassgn.

--dumplrange
Will create a dump of the live ranges of iTemp's

--dumpall
Will cause all the above mentioned dumps to be created.

COPYING

The entire source code for the compiler is distributed under GNU General Public License.

Use sdcc online using onworks.net services