This chapter documents the backend for the Motorola M68k/CPU32/ColdFire
microprocessor family.

@section Legal

    This module is copyright in 2002-2014 by Frank Wille.

    This archive may be redistributed without modifications and used
    for non-commercial purposes.

    Distributing modified versions and commercial usage needs my written
    consent.

    Certain modules may fall under additional copyrights.


@section Additional options for this module

This module provides the following additional options:

@subsection CPU selections
@table @option
    @item -m68000
        Generate code for the MC68000 CPU.

    @item -m68008
        Generate code for the MC68008 CPU.

    @item -m68010
        Generate code for the MC68010 CPU.

    @item -m68020
        Generate code for the MC68020 CPU.

    @item -m68030
        Generate code for the MC68030 CPU.

    @item -m68040
        Generate code for the MC68040 CPU.

    @item -m68060
        Generate code for the MC68060 CPU.

    @item -m68020up
        Generate code for the MC68020-68060 CPU. Be careful with
        instructions like PFLUSHA, which exist on 68030 and 68040/060
        with a different opcode (vasm will use the 040/060 version).

    @item -mcpu32
        Generate code for the CPU32 family (MC6833x, MC6834x, etc.).

    @item -mcf5...
    @itemx -m5...
        Generate code for a ColdFire family CPU. The following types are
        recognized: 5202, 5204, 5206, 520x, 5206e, 5207, 5208, 5210a, 5211a,
        5212, 5213, 5214, 5216, 5224, 5225, 5232, 5233, 5234, 5235, 523x,
        5249, 5250, 5253, 5270, 5271, 5272, 5274, 5275, 5280, 5281, 528x,
        52221, 52553, 52230, 52231, 52232, 52233, 52234, 52235, 52252,
        52254, 52255, 52256, 52258, 52259, 52274, 52277,
        5307, 5327, 5328, 5329, 532x, 5372, 5373, 537x, 53011, 53012, 53013,
        53014, 53015, 53016, 53017, 5301x,
        5407, 5470, 5471, 5472, 5473, 5474, 5475, 547x, 5480, 5481, 5482,
        5483, 5484, 5485, 548x, 54450, 54451, 54452, 54453, 5445x.

    @item -mcfv2
        Generate code for the V2 ColdFire core. This option selects
        ISA_A (no hardware division or MAC), which is the most limited ISA
        supported by 5202, 5204 and 5206. All other ColdFire chips are
        backwards compatible to V2.

    @item -mcfv3
        Generate code for the V3 ColdFire core. This option selects
        ISA_A+, hardware division MAC and EMAC instructions, which are
        supported by nearly all V3 CPUs, except the 5307.

    @item -mcfv4
        Generate code for the V4 ColdFire core. This option selects ISA_B
        and MAC as supported by the 5407.

    @item -mcfv4e
        Generate code for the V4e ColdFire core. This option selects ISA_B,
        USP-, FPU-, MAC- and EMAC-instructions (no hardware division) as
        supported by all 547x and 548x CPUs.

    @item -m68851
        Generate code for the MC68851 MMU. May be used in combination
        with another -m option.

    @item -m68881
        Generate code for the MC68881 FPU. May be used in combination
        with another -m option.

    @item -m68882
        Generate code for the MC68882 FPU. May be used in combination
        with another -m option.
@end table

@subsection Optimization options
@table @option
    @item -no-opt
        Disable all optimizations. Can be seen as a main switch to ignore
        all other optimization options on the command line and in the source.

    @item -opt-allbra
        When specified the assembler will also try to optimize branch
        instructions which already have a valid size extension.
        This option is automatically enabled in @option{-phxass} mode.

    @item -opt-brajmp
        Translate relative branch instructions, whose destination is in a
        different section, into absolute jump instructions.

    @item -opt-clr
        Enables optimization from @code{MOVE #0,<ea>} into @code{CLR <ea>}
        for the MC68000. Note that @code{CLR} will execute a read-modify-write
        cycle on the 68000, so it is disabled by default. With 68010 and
        higher this is a generic standard optimization.

    @item -opt-fconst
        Floating point constants are loaded with the lowest precision
        possible. This means that @code{FMOVE.D #1.0,FP0} would be
        optimized to @code{FMOVE.S #1.0,FP0}, because it is faster and
        shorter at the same precision. The optimization will be performed
        on all FPU instructions with immediate addressing mode.
        When an FDIV-family instruction (@code{FSDIV}, @code{FDDIV},
        @code{FSGLDIV}) is detected it will additionally be checked if the
        immediate constant is a power of 2 and then converted into
        @code{FMUL #1/c,FPn}.

    @item -opt-lsl
        Allows optimization of @code{LSL #1} into @code{ADD}. It is also
        needed to optimize @code{ASL #2} and @code{LSL #2} into two @code{ADD}
        instructions (together with @option{-opt-speed}).
        These optimizations may modify the V-flag, which might not be intended.

    @item -opt-movem
        Enables optimization from @code{MOVEM <ea>,Rn} into
        @code{MOVE <ea>,Rn} (or the other way around). This optimization
        will modify the flags, when the destination is no address
        register.

    @item -opt-mul
        Immediate multplication factors, which are a power of two (from 2
        to 256), are optimized to shifts. Multiplications with zero are
        replaced by a @code{MOVEQ #0,Dn}, with -1 are replaced by a
        @code{NEG.L Dn} and with 1 by @code{EXT.L Dn} or @code{TST.L Dn}
        (long-form). Not all optimizations are available for all cpu types
        (e.g. @code{MULU.W} can only be optimized on ColdFire by using
        the @code{MVZ.W} instruction.
        This optimization will leave the flags in a different state as
        can normally be expected after a multiplication instruction, and
        the size of the optimized code may be bigger than before in a few
        situations (e.g. @code{MULS.W #4,Dn}). The latter will additionally
        require the @option{-opt-speed} flag.

    @item -opt-div
        Unsigned immediate divisors, which are a power of two (from 2 to 256),
        are optimized to shifts. Divisions by 1 are replaced by @code{TST.L Dn}
        (32-bit) or @code{MVZ.W Dn,Dn} (16-bit, ColdFire only). Divisions by
        -1 are replaced by @code{NEG.L Dn} (32-bit) or by a combination of
        @code{NEG.W Dn} and @code{MVZ.W Dn,Dn} (16-bit, ColdFire only).
        This optimization will leave the flags in a different state as
        can normally be expected after a division instruction.

    @item -opt-pea
        Enables optimization from @code{MOVE #x,-(SP)} into @code{PEA x}.
        This optimization will leave the flags unmodified, which might
        not be intended.

    @item -opt-speed
        Optimize for speed, even if this would increase code size.
        For example it enables optimization of @code{ASL.W #2,Dn} into two
        @code{ADD.W Dn,Dn} instructions. Or @code{MULS.W #-4,Dn} into
        @code{EXT.L Dn + ASL.L #2,Dn + NEG.L Dn}.
        Generally the assembler will never optimize a single into multiple
        instructions without this option.

    @item -opt-st
        Enables optimization from @code{MOVE.B #-1,<ea>} into @code{ST <ea>}.
        This optimization will leave the flags unmodified, which might
        not be intended.

    @item -sc
        All @code{JMP} and @code{JSR} instructions to external labels
        will be converted into 16-bit PC-relative jumps.

    @item -showcrit
        Print all critical optimizations which have side effects. Among
        those are @code{-opt-lsl}, @code{-opt-mul}, @code{-opt-st},
        @code{-opt-pea}, @code{-opt-movem} and @code{-opt-clr}.

    @item -showopt
        Print all optimizations and translations vasm is doing
        (same as @code{opt ow+}).
@end table

In its default setting (no @option{-devpac} or @option{-phxass} option)
vasm performs the following optimizations:
@itemize @minus
@item Absolute to PC-relative.
@item Branches without explicit size.
@item Displacements (32 to 16 bit, @code{(0,An)} to @code{(An)}, etc).
@item Optimize floating point constants to the lowest possible precision.
@item Many instruction optimizations which are safe.
@end itemize

@subsection Other options
@table @option
    @item -conv-brackets
        Brackets (@code{'['} and @code{']'}) in an operand are automatically
        converted into parentheses (@code{'('} and @code{')'}) as long as
        the CPU is 68000 or 68010. This is a compatibility option for some
        old assemblers.

    @item -devpac
        All options are initially set to be Devpac compatible. Which means
        that all optimizations are disabled, no debugging symbols will be
        written and vasm will warn about any optimization being done.
        Shift-right operations are performed using an unsigned 32-bit value.
        Other options are the same as vasm's defaults.
        The symbol @code{__G2} is defined, which contains information
        about the selected cpu type.
        It will also automatically enable @option{-guess-ext}.

    @item -elfregs
        Register names are preceded by a '%' to prevent confusion
        with symbol names.

    @item -guess-ext
        Accept illegal size extensions for an instruction, as long as
        the instruction is unsized or there is just a single size possible.
        This is the default setting in PhxAss and Devpac compatibility mode.

    @item -phxass
        PhxAss-compatibilty mode. The "current PC symbol" (e.g. @code{*} in
        mot-syntax module) is set to the instruction's address + 2 whenever
        an instruction is parsed.
        According to the current cpu setting the symbols @code{__CPU},
        @code{__FPU} and @code{__MMU} are defined.
        @code{JMP/JSR (label,PC)} will never be optimized (into a branch,
        for example).
        It will also automatically enable @option{-opt-allbra} and
        @option{-guess-ext}.

    @item -rangewarnings
        Values which are out of range usually produce an error. With this
        option the errors 2026, 2030, 2033 and 2037 will be displayed as
        a warning, allowing the user to create an object file.

    @item -sdreg=<n>
        Set the small data base register to @code{An}. <n> is valid
        between 2 and 6.
@end table

@section General

This backend accepts M68k and CPU32 instructions as described in
Mototola's M68000 family Programmer's Reference Manual. Additionally
it supports ColdFire instructions as described in Motorola's ColdFire
Microprocessor Family Programmer's Reference Manual.

The syntax for the scale factor in ColdFire @code{MAC} instructions is
@code{<<} for left- and @code{>>} for right-shift. The scale factor may be
appended as an optional operand, when needed.
Example: @code{mac d0.l,d1.u,<<}.

The mask flag in @code{MAC} instructions is written as @code{&} and is
appended directly to the effective address operand. Example:
@code{mac d0,d1,(a0)&,d2}.

The target address type is 32bit.

Default alignment for instructions is 2 bytes. The default alignment for
data is 2 bytes, when the data size is larger than 8 bits.

Depending on the selected cpu type the @code{__VASM} symbol will have
a value defined by the following bits:
@table @code
@item bit 0
      MC68000 instruction set. Also used by MC6830x, MC68322, MC68356.
@item bit 1
      MC68010 instruction set.
@item bit 2
      MC68020 instruction set.
@item bit 3
      MC68030 instruction set.
@item bit 4
      MC68040 instruction set.
@item bit 5
      MC68060 instruction set.
@item bit 6
      MC68881 or MC68882 FPU.
@item bit 7
      MC68851 PMMU.
@item bit 8
      CPU32. Any MC6833x or MC6834x CPU.
@item bit 9
      ColdFire ISA_A.
@item bit 10
      ColdFire ISA_A+.
@item bit 11
      ColdFire ISA_B.
@item bit 12
      ColdFire ISA_C.
@item bit 13
      ColdFire hardware division support.
@item bit 14
      ColdFire MAC instructions.
@item bit 15
      ColdFire enhanced MAC instructions.
@item bit 16
      ColdFire USP register.
@item bit 17
      ColdFire FPU instructions.
@item bit 18
      ColdFire MMU instructions.
@end table


@section Extensions

This backend extends the selected syntax module by the following
directives:

@table @code
@item .sdreg <An>
      Equivalents to @code{near <An>}.

@item basereg <expression>,<An>
      Starts a block of base-relative addressing through register @code{An}
      (remember that @code{A7} is not allowed as a base register).
      The programmer has to make sure that <expression> is placed
      into @code{An} first, while the assembler automatically subtracts
      <expression>, which is usually a program label with an optional offset,
      from each displacement in a @code{(d,An)} addressing mode.
      @code{basereg} has priority over the @code{near} directive. Its effect
      can be suspended with the @code{endb} directive.
      It is allowed to use several base registers in parallel.

@item cpu32
      Generate code for the CPU32 family.

@item endb <An>
      Ends a @code{basereg} block and suspends its effect onto the
      specified base register @code{An}. It may be reused with a different
      base expression thereafter (refer to @code{basereg}).

@item far
      Disables small data (base-relative) mode. All data references
      will be absolute.

@item fpu <cpID>
      Enables 68881/68882 FPU code generation. The <cpID> is inserted
      into the FPU instructions to select the correct coprocessor. Note
      that <cpID> is always 1 for the on-chip FPUs in the 68040 and
      68060. A <cpID> of zero will disable FPU code generation.

@item initnear
      Initializes the selected small data register. In contrast to PhxAss,
      where this directive comes from, just a reference to
      @code{_LinkerDB} is generated, which has to be resolved by a linker.

@item machine <cpu_type>
      Makes the assembler generate code for <cpu_type>, which can be
      the following: @code{68000}, @code{68010}, @code{68020}, @code{68030},
      @code{68040}, @code{68060}, @code{68851}, @code{68881}, @code{68882},
      @code{cpu32}. And various ColdFire CPUs, starting with @code{5...}.

@item mc68000
      Generate code for the MC68000 CPU.

@item mc68010
      Generate code for the MC68010 CPU.

@item mc68020
      Generate code for the MC68020 CPU.

@item mc68030
      Generate code for the MC68030 CPU.

@item mc68040
      Generate code for the MC68040 CPU.

@item mc68060
      Generate code for the MC68060 CPU.

@item mcf5...
      Generate code for a ColdFire CPU. The recognized models are listed
      in the assembler-options section.

@item near [<An>]
      Enables small data (base-relative) mode and sets the base register
      to @code{An}. @code{near} without an argument will reactivate a
      previously defined small data mode, which might be switched off
      by a @code{far} directive.

@item near code
      All @code{JMP} and @code{JSR} instructions to external labels
      will be converted into 16-bit PC-relative jumps. The small code
      mode can be switched off by a @code{far} directive.

@item opt <option>[,<option>...]
      Sets Devpac-compatible options. When option @option{-phxass} is
      given, then it will parse PhxAss options (which is discouraged,
      so there is no detailed description here).
      The supported Devpac2-style options are always suffixed by a
      @code{+} or @code{-} to enable or disable the option:
   @table @code
      @item a
        Automatically optimize absolute to PC-relative references.
        Default is off in Devpac-comptability mode, otherwise on.
      @item c
        Case-sensitivity for all symbols, instructions and macros.
        Default is on.
      @item d
        Include all symbols for debugging in the output file.
        Default is off in Devpac-comptability mode, otherwise on.
      @item o
        Enable all optimizations (o1 to o12), or disable all optimizations.
        Default is that all are disabled in Devpac-compatibility mode and
        enabled otherwise.
        When running in native vasm mode this option will also control
        the following safe vasm-specific optimizations (see below):
        @code{og}, @code{of}, @code{oj}.
      @item o1
        Optimize branches without an explicit size extension.
      @item o2
        Standard displacement optimizations (e.g. @code{(0,An) -> (An)}).
      @item o3
        Optimize absolute addresses to short words.
      @item o4
        Optimize @code{move.l} to @code{moveq}.
      @item o5
        Optimize @code{add #x} and @code{sub #x} into their quick forms.
      @item o6
        No effect in vasm.
      @item o7
        Convert @code{bra.b} to @code{nop}, when branching to the next
        instruction.
      @item o8
        Optimize 68020+ base displacements to 16 bit.
      @item o9
        Optimize 68020+ outer displacements to 16 bit.
      @item o10
        Optimize @code{add/sub #x,An} to @code{lea}.
      @item o11
        Optimize @code{lea (d,An),An} to @code{addq/subq}.
      @item o12
        Optimize @code{<op>.l #x,An} to @code{<op>.w #x,An}.
      @item ow
        Show all optimizations being peformed.
        Default is on in Devpac-compatibility mode, otherwise off.
      @item p
        Check if code is position independant. This will cause an error on
        each relocation being required.
        Default is off.
      @item s
        Include symbols in listing file.
        Default is on.
      @item t
        Check size and type of all expressions.
        Default is on.
      @item w
        Show assembler warnings.
        Default is on.
      @item x
        Ignored, as it has very different meaning in the Atari and Amiga
        versions of Devpac. On Atari it enabled an extended debugging format,
        which allowed symbols with more than 8 character (vasm has no
        limitation here, so this is useless). On Amiga it made the assembler
        include only those symbols which were exported by @code{xdef}. So
        @code{x+} would be the same as @code{d-}.
   @end table

   Also the following Devpac3-style options are supported:
   @table @code
      @item autopc
        Corresponds to @code{a+}.
      @item case
        Corresponds to @code{c+}.
      @item chkpc
        Corresponds to @code{p+}.
      @item debug
        Corresponds to @code{d+}.
      @item symtab
        Corresponds to @code{s+}.
      @item type
        Corresponds to @code{t+}.
      @item warn
        Corresponds to @code{w+}.
      @item xdebug
        Corresponds to @code{x+}.
      @item noautopc
        Corresponds to @code{a-}.
      @item nocase
        Corresponds to @code{c-}.
      @item nochkpc
        Corresponds to @code{p-}.
      @item nodebug
        Corresponds to @code{d-}.
      @item nosymtab
        Corresponds to @code{s-}.
      @item notype
        Corresponds to @code{t-}.
      @item nowarn
        Corresponds to @code{w-}.
      @item noxdebug
        Corresponds to @code{x-}.
      @item p=<type>[/<type>]
        Sets the CPU type to any model vasm supports (original Devpac3
        only allowed 68000-68040, 68332, 68881, 68882 and 68851).
   @end table

   The following options are vasm specific and should not be used when
   writing portable source. Using @code{opt o+} in Devpac mode does not
   enable any of these options.
   @table @code
      @item oc
        Enable optimizations to @code{CLR} (refer to @code{-opt-clr}).
      @item od
        Enable optimization of divisions into shifts (refer to
        @code{-opt-div}).
      @item of
        Enable immediate float constant optimizations (refer to
        @code{-opt-fconst}).
      @item og
        Enable generic vasm optimizations. All optimizations which cannot
        be controlled by another option.
      @item oj
        Enable branch to jump translations (refer to @code{-opt-brajmp}).
      @item ol
        Enable shift optimizations to @code{ADD} (refer to @code{-opt-lsl}).
      @item om
        Enable @code{MOVEM} optimizations (refer to @code{-opt-movem}).
      @item op
        Enable optimizations to @code{PEA} (refer to @code{-opt-pea}).
      @item os
        Optimize for speed before optimizing for size (refer to
        @code{-opt-speed}).
      @item ot
        Enable optimizations to @code{ST} (refer to @code{-opt-st}).
      @item ox
        Enable optimization of multiplications into shifts
        (refer to @code{-opt-mul}).
   @end table
   The default state is 'off' for all those vasm specific options.
@end table

The following directives are only available for the Motorola syntax
module:

@table @code
@item <symbol> equr <Rn>
      Define a new symbol named <symbol> and assign the data or
      address register @code{Rn}, which can be used from now on in operands.
      Note that a register symbol must be defined before it can be
      used!

@item <symbol> equrl <reglist>
      Equivalents to @code{<symbol> reg <reglist>}.

@item <symbol> fequr <FPn>
      Define a new symbol named <symbol> and assign the FPU register
      @code{FPn}, which can be used from now on in operands.
      Note that a register symbol must be defined before it can be
      used!

@item <symbol> fequrl <reglist>
      Equivalents to @code{<symbol> freg <reglist>}.

@item <symbol> freg <reglist>
      Defines a new symbol named <symbol> and assign the FPU register
      list <reglist> to it. Registers in a list must be separated
      by a slash (@code{/}) and ranges or registers can be defined
      by using a hyphen (@code{-}). Examples for valid FPU register
      lists are: @code{fp0-fp7}, @code{fp1-3/fp5/fp7}, @code{fpiar/fpcr}.

@item <symbol> reg <reglist>
      Defines a new symbol named <symbol> and assign the register
      list <reglist> to it. Registers in a list must be separated
      by a slash (@code{/}) and ranges or registers can be defined
      by using a hyphen (@code{-}). Examples for valid register lists
      are: @code{d0-d7/a0-a6}, @code{d3-6/a0/a1/a4-5}.

@end table


@section Optimizations

This backend performs the following operand optimizations:

@itemize @minus

@item @code{(0,An)} optimized to @code{(An)}.

@item @code{(d16,An)} translated to @code{(bd32,An,ZDn.w)}, when @code{d16} is not
 between -32768 and 32767 and the selected CPU allows it (68020 up or
 CPU32).

@item @code{(d16,PC)} translated to @code{(bd32,PC,ZDn.w)}, when @code{d16} is not
 between -32768 and 32767 and the selected CPU allows it (68020 up or
 CPU32).

@item @code{(d8,An,Rn)} translated to @code{(bd,An,Rn)}, when @code{d8} is not
 between -128 and 127 and the selected CPU allows it (68020 up or
 CPU32).

@item @code{(d8,PC,Rn)} translated to @code{(bd,PC,Rn)}, when @code{d8} is not
 between -128 and 127 and the selected CPU allows it (68020 up or
 CPU32).

@item @code{<exp>.l} optimized to @code{<exp>.w}, when @code{<exp>} is absolute
 and between -32768 and 32767.

@item @code{<exp>.w} translated to @code{<exp>.l}, when @code{<exp>} is a program
 label or absolute and not between -32768 and 32767.

@item @code{(0,An,...)} optimized to @code{(An,...)} (which means the base
 displacement will be suppressed). This allows further optimization
 to @code{(An)}, when the index is suppressed.

@item @code{(bd16,An,...)} translated to @code{(bd32,An,...)}, when @code{bd16} is
 not between -32768 and 32767.

@item @code{(bd32,An,...)} optimized to @code{(bd16,An,...)}, when @code{bd16} is
 between -32768 and 32767.

@item @code{(bd32,An,ZRn)} optimized to @code{(d16,An)}, when @code{bd32} is
 between -32768 and 32767, and the index is suppressed (zero-Rn).

@item @code{(An,ZRn)} optimized to @code{(An)}, when the index is suppressed.

@item @code{(0,PC,...)} optimized to @code{(PC,...)} (which means the base
 displacement will be suppressed).

@item @code{(bd16,PC,...)} translated to @code{(bd32,PC,...)}, when @code{bd16} is
 not between -32768 and 32767.

@item @code{(bd32,PC,...)} optimized to @code{(bd16,PC,...)}, when @code{bd16} is
 between -32768 and 32767.

@item @code{(bd32,PC,ZRn)} optimized to @code{(d16,PC)}, when @code{bd32} is
 between -32768 and 32767, and the index is suppressed (zero-Rn).

@item @code{([0,Rn,...],...)} optimized to @code{([An,...],...)} (which means the base
 displacement will be suppressed).

@item @code{([bd16,Rn,...],...)} translated to @code{([bd32,An,...],...)}, when @code{bd16}
 is not between -32768 and 32768.

@item @code{([bd32,Rn,...],...)} optimized to @code{([bd16,An,...],...)}, when @code{bd32}
 is between -32768 and 32768.

@item @code{([...],0)} optimized to @code{([...])} (which means the outer displacement
 will be suppressed).

@item @code{([...],od16)} translated to @code{([...],od32)}, when @code{od16} is
 not between -32768 and 32767.

@item @code{([...],od32)} translated to @code{([...],od16)}, when @code{od32} is
 between -32768 and 32767.

@end itemize

Note that an operand optimization will only take place when a displacement's
size was not enforced by the programmer (e.g. @code{(4.l,a0)})!

This backend performs the following instruction optimizations:

@itemize @minus

@item @code{<op>.L #x,An} optimized to @code{<op>.W #x,An}, when @code{x} is
 between -32768 and 32767.

@item @code{ADD.? #x,<ea>} optimized to @code{ADDQ.? #x,<ea>}, when @code{x} is
 between 1 and 8.

@item @code{ADD.? #x,<ea>} optimized to @code{SUBQ.? #x,<ea>}, when @code{x} is
 between -1 and -8.

@item @code{ADDA.? #0,An} and @code{SUBA.? #0,An} will be deleted.

@item @code{ADDA.? #x,An} optimized to @code{LEA (x,An),An}, when @code{x} is
 between -32768 and 32767.

@item @code{ANDI.L #$ff,Dn} optimized to @code{MVZ.B Dn,Dn},
 for ColdFire ISA_B/C.

@item @code{ANDI.L #$ffff,Dn} optimized to @code{MVZ.W Dn,Dn},
 for ColdFire ISA_B/C.

@item @code{ANDI.? #0,<ea>} optimized to @code{CLR.? <ea>}, when allowed
 by the option @code{-opt-clr} or a different CPU than the MC68000 was
 selected.

@item @code{ANDI.? #-1,<ea>} optimized to @code{TST.? <ea>}.

@item @code{ASL.? #1,Dn} optimized to @code{ADD.? Dn,Dn} for 68000 and 68010.

@item @code{ASL.? #2,Dn} optimized into a sequence of two @code{ADD.? Dn,Dn}
for 68000 and 68010, when the operation size is either byte or word and
the options @code{-opt-speed} and @code{-opt-lsl} are given.

@item @code{B<cc> <label>} translated into a combination of
 @code{B!<cc> *+8} and @code{JMP <label>}, when <label> is not defined in the
 same section (and option @code{-opt-brajmp} is given),
 or outside the range of -32768 to 32767 bytes from the current address
 when the selected CPU is not 68020 up, CPU32 or ColdFire ISA_B/C.

@item @code{B<cc> <label>} is automatically optimized to 8-bit, 16-bit or
 32-bit (68020 up, CPU32, MCF5407 only), whatever fits best. When the
 selected CPU doesn't support 32-bit branches it will try to change the
 conditional branch into a @code{B<!cc> *+8} and @code{JMP <label>} sequence.

@item @code{BRA <label>} translated to @code{JMP <label>}, when <label> is
 not defined in the same section (and option @code{-opt-brajmp} is given),
 or outside the range of -32768 to 32767 bytes from the current address
 when the selected CPU is not 68020 up, CPU32 or ColdFire ISA_B/C.

@item @code{BSR <label>} translated to @code{JSR <label>}, when <label> is
 not defined in the same section (and option @code{-opt-brajmp} is given),
 or outside the range of -32768 to 32767 bytes from the current address
 when the selected CPU is not 68020 up, CPU32 or ColdFire ISA_B/C.

@item @code{<cp>B<cc> <label>} is automatically optimized to 16-bit or 32-bit,
 whatever fits best. <cp> means coprocessor and is @code{P} for the PMMU
 and @code{F} for the FPU.

@item @code{CLR.L Dn} optimized to @code{MOVEQ #0,Dn}.

@item @code{CMP.? #0,<ea>} optimized to @code{TST.? <ea>}. The selected CPU type
 must be MC68020 up, ColdFire or CPU32 to support address register direct
 as effective address (@code{<ea>}).

@item @code{DIVS.W/DIVU.W #1,Dn} optimized to @code{MVZ.W Dn,Dn}, for
ColdFire ISA_B/C (@code{-opt-div}).

@item @code{DIVS.W #-1,Dn} optimized to the sequence of @code{NEG.W Dn} and
@code{MVZ.W Dn,Dn} (@code{-opt-div} and @code{-opt-speed}).

@item @code{DIVS.L/DIVU.L #1,Dn} optimized to @code{TST.L Dn}
(@code{-opt-div}).

@item @code{DIVS.L #-1,Dn} optimized to @code{NEG.L Dn}
(@code{-opt-div}).

@item @code{DIVU.L #2..256,Dn} optimized to @code{LSR.L #x,Dn}
(@code{-opt-div}).

@item @code{EORI.? #-1,<ea>} optimized to @code{NOT.? <ea>}.

@item @code{EORI.? #0,<ea>} optimized to @code{TST.? <ea>}.

@item @code{FMOVEM.? <reglist>} is deleted, when the register list was empty.

@item @code{FxDIV.? #m,FPn} optimized to @code{FxMUL.? #1/m,FPn} when m is
a power of 2 and option @code{-opt-fconst} is given.

@item @code{JMP <label>} optimized to @code{BRA.? <label>}, when <label> is defined
 in the same section and in the range of -32768 to 32767 bytes from the
 current address.
 Note that @code{JMP (<lab>,PC)} is never optimized.

@item @code{JSR <label>} optimized to @code{BSR.? <label>}, when <label> is defined
 in the same section and in the range of -32768 to 32767 bytes from the
 current address.
 Note that @code{JSR (<lab>,PC)} is never optimized.

@item @code{LEA 0,An} optimized to @code{SUBA.L An,An}.

@item @code{LEA (0,An),An} and @code{LEA (An),An} will be deleted.

@item @code{LEA (d,An),An} is optimized to @code{ADDQ.L #d,An} when @code{d}
 is between 1 and 8 and to @code{SUBQ.L #-d,An} when @code{d} is between
 -1 and -8.

@item @code{LEA (d,Am),An} will be translated into a combination of
 @code{MOVEA} and @code{ADDA.L} for 68000 and 68010, when @code{d} is lower
 than -32768 or higher than 32767. The @code{MOVEA} will be omitted when
 @code{Am} and @code{An} are identical. Otherwise @code{-opt-speed} is
 required.

@item @code{LINK.L An,#x} optimized to @code{LINK.W An,#x}, when @code{x} is
 between -32768 and 32767.

@item @code{LINK.W An,#x} translated to @code{LINK.L An,#x}, when @code{x} is
 not between -32768 and 32767 and selected CPU supports this instruction.

@item @code{LSL.? #1,Dn} optimized to @code{ADD.? Dn,Dn} for 68000 and 68010,
 when option @code{-opt-lsl} is given.

@item @code{LSL.? #2,Dn} optimized into a sequence of two @code{ADD.? Dn,Dn}
for 68000 and 68010, when the operation size is either byte or word and
the options @code{-opt-speed} and @code{-opt-lsl} are given.

@item @code{MOVE.? #0,<ea>} optimized to @code{CLR.? <ea>}, when allowed by
 the option @code{-opt-clr} or a different CPU than the MC68000 was
 selected.

@item @code{MOVE.? #x,-(SP)} optimized to @code{PEA x}, when allowed by the
 option @code{-opt-pea}. The move-size must not be byte (@code{.b}).

@item @code{MOVE.B #-1,<ea>} optimized to @code{ST <ea>}, when allowed by the
 option @code{-opt-st}.

@item @code{MOVE.L #x,Dn} optimized to @code{MOVEQ #x,Dn}, when @code{x} is
 between -128 and 127.

@item @code{MOVE.L #x,<ea>} optimized to @code{MOV3Q #x,<ea>}, for ColdFire
 ISA_B and ISA_C, when @code{x} is -1 or between 1 and 7.

@item @code{MOVEA.? #0,An} optimized to @code{SUBA.L An,An}.

@item @code{MOVEA.L #x,An} optimized to @code{MOVEA.W #x,An}, when @code{x} is
 between -32768 and 32767.

@item @code{MOVEA.L #label,An} optimized to @code{LEA label,An}, which could
 allow further optimization to @code{LEA label(PC),An}.

@item @code{MOVEM.? <reglist>} is deleted, when the register list was empty.

@item @code{MOVEM.? <ea>,An} optimized to @code{MOVE.? <ea>,An}, when the
 register list only contains a single address register.

@item @code{MOVEM.? <ea>,Rn} optimized to @code{MOVE.? <ea>,Rn} and
 @code{MOVEM.? Rn,<ea>} optimized to @code{MOVE.? Rn,<ea>}, when allowed
 by the option @code{-opt-movem} or when just loading an address register.

@item @code{MOVEM.? <ea>,Rm/Rn} and @code{MOVEM.? Rm/Rn,<ea>} are optimized
 into a sequence of two @code{MOVE} for all cpus except 68000 and 68010.
 Complex addressing modes with displacements or addresses are optimized
 for 68040 only. Has to be enabled by the options @code{-opt-movem} and
 @code{-opt-speed}.

@item @code{MULS.?/MULU.? #0,Dn} optimized to @code{MOVEQ #0,Dn}
(@code{-opt-mul}).

@item @code{MULS.?/MULU.? #1,Dn} is deleted (@code{-opt-mul}).

@item @code{MULS.W #-1,Dn} optimized to the sequence @code{EXT.L Dn} and
@code{NEG.L Dn} (@code{-opt-mul} and @code{-opt-speed}).

@item @code{MULS.L #-1,Dn} optimized to @code{NEG.L Dn} (@code{-opt-mul}).

@item @code{MULS.W #2..256,Dn} optimized to the sequence @code{EXT.L Dn} and
@code{ASL.L #x,Dn} (@code{-opt-mul} and @code{-opt-speed}).

@item @code{MULS.W #-2..-256,Dn} optimized to the sequence @code{EXT.L Dn},
@code{ASL.L #x,Dn} and @code{NEG.L Dn} (@code{-opt-mul} and @code{-opt-speed}).

@item @code{MULS.L #2..256,Dn} optimized to @code{ASL.L #x,Dn}
(@code{-opt-mul}).

@item @code{MULS.L #-2..-256,Dn} optimized to the sequence @code{ASL.L #x,Dn}
and @code{NEG.L Dn} (@code{-opt-mul} and @code{-opt-speed}).

@item @code{MULU.W #2..256,Dn} optimized to the sequence @code{MVZ.W Dn,Dn} and
@code{ASL.L #x,Dn} for ColdFire ISA_B/C (@code{-opt-mul} and @code{-opt-speed}).

@item @code{MULU.L #2..256,Dn} optimized to @code{LSL.L #x,Dn}
(@code{-opt-mul}).

@item @code{MVZ.? #x,Dn} and @code{MVS.? #x,Dn} are optimized to
 @code{MOVEQ #x,Dn}.

@item @code{ORI.? #0,<ea>} optimized to @code{TST.? <ea>}.

@item @code{SUB.? #x,<ea>} optimized to @code{SUBQ.? #x,<ea>}, when @code{x} is
 between 1 and 8.

@item @code{SUB.? #x,<ea>} optimized to @code{ADDQ.? #x,<ea>}, when @code{x} is
 between -1 and -8.

@item @code{SUBA.? #x,An} optimized to @code{LEA (-x,An),An}, when @code{x} is
 between -32767 and 32768.

@end itemize

@section Known Problems

    Some known problems of this module at the moment:

@itemize @minus

@item In some rare cases, mainly by stupid input sources, the optimizer
might oscillate forever between two states. When this happens, assembly
will be terminated automatically after some time.

@end itemize

@section Error Messages

This module has the following error messages:

@itemize @minus
@item 2001: instruction not supported on selected architecture
@item 2002: illegal addressing mode
@item 2003: invalid register list
@item 2004: missing ) in register indirect addressing mode
@item 2005: address register required
@item 2006: bad size extension
@item 2007: displacement at bad position
@item 2008: base or index register expected
@item 2009: missing ] in memory indirect addressing mode
@item 2010: no extension allowed here
@item 2011: illegal scale factor
@item 2012: can't scale PC register
@item 2013: index register expected
@item 2014: too many ] in memory indirect addressing mode
@item 2015: missing outer displacement
@item 2016: %c expected
@item 2017: can't use PC register as index
@item 2019: data register required
@item 2020: illegal bitfield width/offset
@item 2021: constant integer expression required
@item 2022: value from -64 to 63 required for k-factor
@item 2023: need 32 bits to reference a program label
@item 2024: option expected
@item 2025: absolute value expected
@item 2026: operand value out of range: %ld (valid: %ld..%ld)
@item 2027: label in operand required
@item 2028: using signed operand as unsigned: %ld (valid: %ld..%ld), %ld to fix
@item 2029: branch destination out of range
@item 2030: displacement out of range
@item 2031: absolute displacement expected
@item 2032: unknown option %c%c ignored
@item 2033: absolute short address out of range
@item 2034: 8-bit branch with zero displacement was converted to 16-bit
@item 2035: illegal opcode extension
@item 2036: extension for unsized instruction ignored
@item 2037: immediate operand out of range
@item 2038: immediate operand has illegal type or size
@item 2039: data objects with %d bits size are not supported
@item 2040: data out of range
@item 2041: data has illegal type
@item 2042: illegal combination of ColdFire addressing modes
@item 2043: FP register required
@item 2044: unknown cpu type
@item 2045: register expected
@item 2046: link.w changed to link.l
@item 2047: branch out of range changed to jmp
@item 2048: lea-displacement out of range, changed into move/add
@item 2049: translated (A%d) into (0,A%d) for movep
@item 2050: operand optimized: %s
@item 2051: operand translated: %s
@item 2051: instruction optimized: %s
@item 2053: instruction translated: %s
@item 2054: branch optimized into: b<cc>.%c
@item 2055: branch translated into: b<cc>.%c
@item 2056: basereg A%d already in use
@item 2057: basereg A%d is already free
@item 2058: short-branch to following instruction turned into a nop
@item 2059: not a valid small data register
@item 2060: small data mode is not enabled
@item 2061: division by zero

@end itemize
