IBM RS/6000 and PowerPC Options
-------------------------------

   These `-m' options are defined for the IBM RS/6000 and PowerPC:
`-mpower'
`-mno-power'
`-mpower2'
`-mno-power2'
`-mpowerpc'
`-mno-powerpc'
`-mpowerpc-gpopt'
`-mno-powerpc-gpopt'
`-mpowerpc-gfxopt'
`-mno-powerpc-gfxopt'
     GNU CC supports two related instruction set architectures for the
     RS/6000 and PowerPC.  The "POWER" instruction set are those
     instructions supported by the `rios' chip set used in the original
     RS/6000 systems and the "PowerPC" instruction set is the
     architecture of the Motorola MPC6xx microprocessors.  The PowerPC
     architecture defines 64-bit instructions, but they are not
     supported by any current processors.

     Neither architecture is a subset of the other.  However there is a
     large common subset of instructions supported by both.  An MQ
     register is included in processors supporting the POWER
     architecture.

     You use these options to specify which instructions are available
     on the processor you are using.  The default value of these
     options is determined when configuring GNU CC.  Specifying the
     `-mcpu=CPU_TYPE' overrides the specification of these options.  We
     recommend you use that option rather than these.

     The `-mpower' option allows GNU CC to generate instructions that
     are found only in the POWER architecture and to use the MQ
     register.  Specifying `-mpower2' implies `-power' and also allows
     GNU CC to generate instructions that are present in the POWER2
     architecture but not the original POWER architecture.

     The `-mpowerpc' option allows GNU CC to generate instructions that
     are found only in the 32-bit subset of the PowerPC architecture.
     Specifying `-mpowerpc-gpopt' implies `-mpowerpc' and also allows
     GNU CC to use the optional PowerPC architecture instructions in the
     General Purpose group, including floating-point square root.
     Specifying `-mpowerpc-gfxopt' implies `-mpowerpc' and also allows
     GNU CC to use the optional PowerPC architecture instructions in
     the Graphics group, including floating-point select.

     If you specify both `-mno-power' and `-mno-powerpc', GNU CC will
     use only the instructions in the common subset of both
     architectures plus some special AIX common-mode calls, and will
     not use the MQ register.  Specifying both `-mpower' and `-mpowerpc'
     permits GNU CC to use any instruction from either architecture and
     to allow use of the MQ register; specify this for the Motorola
     MPC601.

`-mnew-mnemonics'
`-mold-mnemonics'
     Select which mnemonics to use in the generated assembler code.
     `-mnew-mnemonics' requests output that uses the assembler mnemonics
     defined for the PowerPC architecture, while `-mold-mnemonics'
     requests the assembler mnemonics defined for the POWER
     architecture.  Instructions defined in only one architecture have
     only one mnemonic; GNU CC uses that mnemonic irrespective of which
     of these options is specified.

     PowerPC assemblers support both the old and new mnemonics, as will
     later POWER assemblers.  Current POWER assemblers only support the
     old mnemonics.  Specify `-mnew-mnemonics' if you have an assembler
     that supports them, otherwise specify `-mold-mnemonics'.

     The default value of these options depends on how GNU CC was
     configured.  Specifying `-mcpu=CPU_TYPE' sometimes overrides the
     value of these option.  Unless you are building a cross-compiler,
     you should normally not specify either `-mnew-mnemonics' or
     `-mold-mnemonics', but should instead accept the default.

`-mcpu=CPU_TYPE'
     Set architecture type, register usage, choice of mnemonics, and
     instruction scheduling parameters for machine type CPU_TYPE.  By
     default, CPU_TYPE is the target system defined when GNU CC was
     configured.  Supported values for CPU_TYPE are `rios1', `rios2',
     `rsc', `601', `603', `604', `power', `powerpc', `403', and
     `common'.  `-mcpu=power' and `-mcpu=powerpc' specify generic POWER
     and pure PowerPC (i.e., not MPC601) architecture machine types,
     with an appropriate, generic processor model assumed for
     scheduling purposes.

     Specifying `-mcpu=rios1', `-mcpu=rios2', `-mcpu=rsc', or
     `-mcpu=power' enables the `-mpower' option and disables the
     `-mpowerpc' option; `-mcpu=601' enables both the `-mpower' and
     `-mpowerpc' options; `-mcpu=603', `-mcpu=604', `-mcpu=403', and
     `-mcpu=powerpc' enable the `-mpowerpc' option and disable the
     `-mpower' option; `-mcpu=common' disables both the `-mpower' and
     `-mpowerpc' options.

     To generate code that will operate on all members of the RS/6000
     and PowerPC families, specify `-mcpu=common'.  In that case, GNU CC
     will use only the instructions in the common subset of both
     architectures plus some special AIX common-mode calls, and will
     not use the MQ register.  GNU CC assumes a generic processor model
     for scheduling purposes.

     Specifying `-mcpu=rios1', `-mcpu=rios2', `-mcpu=rsc', or
     `-mcpu=power' also disables the `new-mnemonics' option.
     Specifying `-mcpu=601', `-mcpu=603', `-mcpu=604', `403', or
     `-mcpu=powerpc' also enables the `new-mnemonics' option.

`-mfull-toc'
`-mno-fp-in-toc'
`-mno-sum-in-toc'
`-mminimal-toc'
     Modify generation of the TOC (Table Of Contents), which is created
     for every executable file.  The `-mfull-toc' option is selected by
     default.  In that case, GNU CC will allocate at least one TOC
     entry for each unique non-automatic variable reference in your
     program.  GNU CC will also place floating-point constants in the
     TOC.  However, only 16,384 entries are available in the TOC.

     If you receive a linker error message that saying you have
     overflowed the available TOC space, you can reduce the amount of
     TOC space used with the `-mno-fp-in-toc' and `-mno-sum-in-toc'
     options.  `-mno-fp-in-toc' prevents GNU CC from putting
     floating-point constants in the TOC and `-mno-sum-in-toc' forces
     GNU CC to generate code to calculate the sum of an address and a
     constant at run-time instead of putting that sum into the TOC.
     You may specify one or both of these options.  Each causes GNU CC
     to produce very slightly slower and larger code at the expense of
     conserving TOC space.

     If you still run out of space in the TOC even when you specify
     both of these options, specify `-mminimal-toc' instead.  This
     option causes GNU CC to make only one TOC entry for every file.
     When you specify this option, GNU CC will produce code that is
     slower and larger but which uses extremely little TOC space.  You
     may wish to use this option only on files that contain less
     frequently executed code.

`-msoft-float'
`-mhard-float'
     Generate code that does not use (uses) the floating-point register
     set.  Software floating point emulation is provided if you use the
     `-msoft-float' option, and pass the option to GNU CC when linking.

`-mmultiple'
`-mno-multiple'
     Generate code that uses (does not use) the load multiple word
     instructions and the store multiple word instructions.  These
     instructions are generated by default on POWER systems, and not
     generated on PowerPC systems.  Do not use `-mmultiple' on little
     endian PowerPC systems, since those instructions do not work when
     the processor is in little endian mode.

`-mstring'
`-mno-string'
     Generate code that uses (does not use) the load string
     instructions and the store string word instructions to save
     multiple registers and do small block moves.  These instructions
     are generated by default on POWER systems, anod not generated on
     PowerPC systems.  Do not use `-mstring' on little endian PowerPC
     systems, since those instructions do not work when the processor
     is in little endian mode.

`-mno-bit-align'
`-mbit-align'
     On System V.4 and embedded PowerPC systems do not (do) force
     structures and unions that contain bit fields to be aligned to the
     base type of the bit field.

     For example, by default a structure containing nothing but 8
     `unsigned' bitfields of length 1 would be aligned to a 4 byte
     boundary and have a size of 4 bytes.  By using `-mno-bit-align',
     the structure would be aligned to a 1 byte boundary and be one
     byte in size.

`-mno-strict-align'
`-mstrict-align'
     On System V.4 and embedded PowerPC systems do not (do) assume that
     unaligned memory references will be handled by the system.

`-mrelocatable'
`-mno-relocatable'
     On embedded PowerPC systems generate code that allows (does not
     allow) the program to be relocated to a different address at
     runtime.

`-mno-toc'
`-mtoc'
     On System V.4 and embedded PowerPC systems do not (do) assume that
     register 2 contains a pointer to a global area pointing to the
     addresses used in the program.

`-mno-traceback'
`-mtraceback'
     On embedded PowerPC systems do not (do) generate a traceback tag
     before the start of the function.  This tag can be used by the
     debugger to identify where the start of a function is.

`-mlittle'
`-mlittle-endian'
     On System V.4 and embedded PowerPC systems compile code for the
     processor in little endian mode.  The `-mlittle-endian' option is
     the same as `-mlittle'.

`-mbig'
`-mbig-endian'
     On System V.4 and embedded PowerPC systems compile code for the
     processor in big endian mode.  The `-mbig-endian' option is the
     same as `-mbig'.

`-mcall-sysv'
     On System V.4 and embedded PowerPC systems compile code using
     calling conventions that adheres to the March 1995 draft of the
     System V Application Binary Interface, PowerPC processor
     supplement.  This is the default unless you configured GCC using
     `powerpc-*-eabiaix'.

`-mcall-aix'
     On System V.4 and embedded PowerPC systems compile code using
     calling conventions that are similar to those used on AIX.  This
     is the default if you configured GCC using `powerpc-*-eabiaix'.

`-mprototype'
`-mno-prototype'
     On System V.4 and embedded PowerPC systems assume that all calls to
     variable argument functions are properly prototyped.  Otherwise,
     the compiler must insert an instruction before every non
     prototyped call to set or clear bit 6 of the condition code
     register (CR) to indicate whether floating point values were
     passed in the floating point registers in case the function takes
     a variable arguments.  With `-mprototype', only calls to
     prototyped variable argument functions will set or clear the bit.