sdccman.txt

很少见的源码公开的msc51和z80的c编译器。

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.

-Aquestion(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.

-Aquestion (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 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. See section Memory
Models for more details.

--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).

 Optimization 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. See
section Switch Statements for more details. 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. see section Parameters and Local
Variables for more details. 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.
See section on external stack for more details.

--callee-saves function1[,function2][,function3].... The
compiler by default uses a caller saves convention for register
saving across function calls, however this can cause unneccessary
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.
Also see #pragma CALLEE-SAVES.

--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.
For more information see documentation for SDCDB.

--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. See section
Peep Hole optimizations for details on how to write these
rules.

-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. See section Installation
for more details.

--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 see section on Cyclomatic Complexity
for more details.

--float-reent  Floating point library is compiled as reentrant.See
section Installation for more details.

--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.

 MCS51/DS390 Storage Class Language Extensions

In addition to the ANSI storage classes SDCC allows the following
MCS51 specific storage classes.

 xdata

Variables declared with this storage class will be placed
in the extern RAM. This is the default storage class for
Large Memory model, e.g.:

xdata unsigned char xduc;

 data

This is the default storage class for Small Memory model.
Variables declared with this storage class will be allocated
in the internal RAM, e.g.:

data int iramdata;

 idata

Variables declared with this storage class will be allocated
into the indirectly addressable portion of the internal
ram of a 8051, e.g.:

idata int idi;

 bit

This is a data-type and a storage class specifier. When a
variable is declared as a bit, it is allocated into the
bit addressable memory of 8051, e.g.:

bit iFlag;

 sfr / sbit

Like the bit keyword, sfr / sbit signifies both a data-type
and storage class, they are used to describe the special
function registers and special bit variables of a 8051,
eg:

sfr at 0x80 P0; /* special function register P0 at location
0x80 */
sbit at 0xd7 CY; /* CY (Carry Flag) */

 Pointers

SDCC allows (via language extensions) pointers to explicitly
point to any of the memory spaces of the 8051. In addition
to the explicit pointers, the compiler also allows a _generic
class of pointers which can be used to point to any of the
memory spaces.

Pointer declaration examples:

/* pointer physically in xternal ram pointing to object in
internal ram */ 
data unsigned char * xdata p;

/* pointer physically in code rom pointing to data in xdata
space */ 
xdata unsigned char * code p;

/* pointer physically in code space pointing to data in code
space */ 
code unsigned char * code p;

/* the folowing is a generic pointer physically located in
xdata space */
char * xdata p;