c68.txt

一款拥有一定历史的C语言编译器

                                  generated code.

                        flow      This tries to  analyse the flow of the
                                  code to  eliminate redundant  loads of
                                  registers.  A  significant size  savig
                                  normally  results  from  this  option.
                                  However if  it goes wrong, the results
                                  can be rather unpredictable.

                        Default:  -peep=all

              -probe=no|yes
                        Specify whether stack probes should be generated
                        each time a stack frame is generated.  These can
                        be  desirable   if  using   the  compiler  in  a
                        multi-tasking environment and with a 680x0 based
                        system which has hardware protection for invalid
                        memory accesses.  The problem is that not enough
                        space is  always left  on  the  stack  to  store
                        information for a restart of an instruction, and
                        stack probes  insure that  the stack  has enough
                        allocated memory to accommodate the needs of the
                        routine.   Support   for  this  option  is  only
                        included if  the PROBES configuration option was
                        set when the compiler was built.

                        Default:  -probe=no

                        Note:     The compiler  as   supplied   is   not
                                  normally  set   to  have  this  option
                                  compiled in.   Also there  is no point
                                  in attempting to use it if your system
                                  does  not   have  hardware  that  will
                                  detect  attempts   to  access   memory
                                  addresses that are outside the stack.


              -regdata=an
                        Specify which address  register is to be used as
                        the index register for access to variables. This
                        parameter is only relevant if the setting of the
                        -datamode specifies  that absolute addressing is
                        not being  used. Note that no check is made that
                        the settings  do not  conflict with  any of  the
                        other -regxxxx options.

                        Default: -regdata=a5

              -regframe=an
                        Specify which address  register is to be used as
                        the frame  pointer. Note  that no  check is made
                        that the  settings do  not conflict  with any of
                        the other -regxxxx options.

                        Default: -regframe=a6

              -regtemp=register_list
                        Specify which  registers are  treated as scratch
                        registers.  Note that no check is made to ensure
                        that you have left enough for the compiler to be
                        able to  sensibly generate  code,  or  that  the
                        settings do  not conflict  with any of the other
                        -regxxxx options.

                        Default: -regtemp=d0,d1,d2,a0,a1,fp0,fp1,fp2

              -regunused=register_list
                        Specify which  registers  should  not  be  used.
                        This would  be used if you needed to ensure that
                        a particular  register was  never corrupted  for
                        some reason.    Note that  issued libraries will
                        not have been built with this setting, so use in
                        average programs  is not  much  use  unless  the
                        libraries are  rebuilt to  match.  Note  that no
                        check is  made that the settings do not conflict
                        with any of the other -regxxxx options.

                        Default: -regunused=

              -target=n Used to  specify   the  target  processor  type.
                        Values supported are:
                             68000
                             68010
                             68020
                             68030
                             68040

                        Default:  -target=68000



              If support  for multiple  processors and/or assemblers was
              configured when  the compiler  was built,  then a  you can
              specify a  68k target  with a specific assembler using the
              following options:

              -ack68k   Generate 680x0  code.   Use  the  ACK  assembler
                        syntax for the output.

              -cpm68k   Generate 680x0  code.   Use  the  CPM  assembler
                        syntax for the output.

              -gas68K   Generate 680x0  code.   Use  the  GNU  assembler
                        syntax for the output.

              -qmc68k   Generate 680x0  code.  Use  the  QMAC  assembler
                        syntax for the output.



         INTEL 386 OPTIONS

              The options  in this  section apply when generating 32-bit
              code for Intel 386 (or better) processors.  They will only
              be available  if support  for the  Intel 386 processor was
              specified at the time the compiler was built.

              -fpu=yes|no
                        Specify whether  operations  involving  floating
                        point variables should generate in-line calls to
                        a hardware floating point unit, or whether calls
                        are made  instead to  library support  routines.
                        Using library  support routines  allows floating
                        point operations  to be  carried out  purely  in
                        software.

                        Default:  -fpu=yes

                        N.B. We do not supply  suitable library routines
                             to do  software emulation of floating point
                             with the compiler.

              -fpureturn=yes|no
                        This option is used to tell the compiler whether
                        the library  routines  are  such  that  floating
                        point results  are returned  in the hardware FPU
                        registers, or  in normal  registers.   Note  you
                        should not  normally change  this value from the
                        default  unless   you  have   been  specifically
                        advised to do so.

                        Default:  -fpureturn=no

              -peep=none|peepopt_list|all
                        Control the  level of peephole optimisation that
                        should be  done. Past  experience has shown that
                        some of  the more  obscure bugs  reported on the
                        compiler are  those where the peephole optimiser
                        part  of   the  compiler  has  made  an  invalid
                        optimisation.   You  would  therefore  use  this
                        option if  you suspect  that  the  compiler  has
                        generated incorrect  code, and  you want to look
                        at what would be generated if some or all of the
                        the peephole optimisation was not done.

                        The meanings of the options are:

                        none      All peephole     optimisations     are
                                  suppressed.

                        all       All peephole     optimisations     are
                                  performed.  It is equivalent to giving
                                  -peep=flow.

                        You can also exercise  a finer  level of control
                        by specifying  the exact combination of peephole
                        optimisations that  you want  from the following
                        options:

                        flow      This tries to  analyse the flow of the
                                  code to  eliminate redundant  loads of
                                  registers.  A  significant size  savig
                                  normally  results  from  this  option.
                                  However if  it goes wrong, the results
                                  can be rather unpredictable.

                        Default:  -peep=all


              If support for multiple assemblers and/or processors types
              was specified  when the  compiler was  built, then  a  386
              processor  target   plus  a   specific  assembler  can  be
              specified using the following options:

              -bas386   Generate 386  code.  Use  the syntax  for  Bruce
                        Evan's 386 assembler for the output.

              -gas386   Generate 386  code.  Use  the GNU  386 assembler
                        syntax for the output.
              -masm386  Generate  386  code.   Use  the  Microsoft  MASM
                        assembler syntax for the output

              -sysv386  Generate 386  code.  Use the Unix SVR4 assembler
                        syntax for the output.




         INTEL 8086 OPTIONS

              The options  listed in  this section apply when generating
              16-bit code  for use  on Intel processors.  They will only
              be available  if support for the Intel 8086 processor type
              was specified at the time the compiler was built.

              -fpu=yes|no
                        Specify whether  operations  involving  floating
                        point variables should generate in-line calls to
                        the a  hardware floating  point unit, or whether
                        calls  are   made  instead  to  library  support
                        routines. Using  library support routines allows
                        floating point  operations  to  be  carried  out
                        purely in software.

                        Default:  -fpu=yes

              -peep=none|peepopt_list|all
                        Control the  level of peephole optimisation that
                        should be  done. Past  experience has shown that
                        some of  the more  obscure bugs  reported on the
                        compiler are  those where the peephole optimiser
                        part  of   the  compiler  has  made  an  invalid
                        optimisation.   You  would  therefore  use  this
                        option if  you suspect  that  the  compiler  has
                        generated incorrect  code, and  you want to look
                        at what would be generated if some or all of the
                        the peephole optimisation was not done.

                        The meanings of the options are:

                        none      All peephole     optimisations     are
                                  suppressed.

                        all       All peephole     optimisations     are
                                  performed.  It is equivalent to giving
                                  -peep=flow.

                        You can also exercise  a finer  level of control
                        by specifying  the exact combination of peephole
                        optimisations that  you want  from the following
                        options:

                        flow      This tries to  analyse the flow of the
                                  code to  eliminate redundant  loads of
                                  registers.  A  significant size  savig