[BACK]Return to m68k-defs.m4 CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / gmp / mpn / m68k

Annotation of OpenXM_contrib/gmp/mpn/m68k/m68k-defs.m4, Revision 1.1

1.1     ! ohara       1: divert(-1)
        !             2:
        !             3: dnl  m4 macros for 68k assembler.
        !             4:
        !             5: dnl  Copyright 2001, 2002 Free Software Foundation, Inc.
        !             6: dnl
        !             7: dnl  This file is part of the GNU MP Library.
        !             8: dnl
        !             9: dnl  The GNU MP Library is free software; you can redistribute it and/or
        !            10: dnl  modify it under the terms of the GNU Lesser General Public License as
        !            11: dnl  published by the Free Software Foundation; either version 2.1 of the
        !            12: dnl  License, or (at your option) any later version.
        !            13: dnl
        !            14: dnl  The GNU MP Library is distributed in the hope that it will be useful,
        !            15: dnl  but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            16: dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            17: dnl  Lesser General Public License for more details.
        !            18: dnl
        !            19: dnl  You should have received a copy of the GNU Lesser General Public
        !            20: dnl  License along with the GNU MP Library; see the file COPYING.LIB.  If
        !            21: dnl  not, write to the Free Software Foundation, Inc., 59 Temple Place -
        !            22: dnl  Suite 330, Boston, MA 02111-1307, USA.
        !            23:
        !            24:
        !            25: dnl  The default m4 `#' commenting interferes with the assembler syntax for
        !            26: dnl  immediates.  `|' would be correct, but it interferes with "||" in
        !            27: dnl  eval().  Would like to disable commenting, but that's not possible (see
        !            28: dnl  mpn/asm-defs.m4), so use `;' which should be harmless.
        !            29:
        !            30: changecom(;)
        !            31:
        !            32:
        !            33: dnl  Called: PROLOGUE_cpu(GSYM_PREFIX`'foo)
        !            34: dnl
        !            35: dnl  Same as the standard PROLOGUE, but align to 2 bytes not 4.
        !            36:
        !            37: define(`PROLOGUE_cpu',
        !            38: m4_assert_numargs(1)
        !            39: `      TEXT
        !            40:        ALIGN(2)
        !            41:        GLOBL   `$1' GLOBL_ATTR
        !            42:        TYPE(`$1',`function')
        !            43: `$1'LABEL_SUFFIX')
        !            44:
        !            45:
        !            46: dnl  Usage: d0, etc
        !            47: dnl
        !            48: dnl  Expand to d0 or %d0 according to the assembler's requirements.
        !            49: dnl
        !            50: dnl  Actually d0 expands to `d0' or %`d0', the quotes protecting against
        !            51: dnl  further expansion.  Definitions are made even if d0 is to be just `d0',
        !            52: dnl  so that any m4 quoting problems will show up everywhere, not just on a
        !            53: dnl  %d0 system.
        !            54: dnl
        !            55: dnl  Care must be taken with quoting when using these in a definition.  For
        !            56: dnl  instance the quotes in the following are essential or two %'s will be
        !            57: dnl  produced when `counter' is used.
        !            58: dnl
        !            59: dnl         define(counter, `d7')
        !            60: dnl
        !            61:
        !            62: dnl  Called: m68k_reg(r)
        !            63: define(m68k_reg,
        !            64: m4_assert_numargs(1)
        !            65: m4_assert_defined(`WANT_REGISTER_PERCENT')
        !            66: `ifelse(WANT_REGISTER_PERCENT,yes,%)`$1'')
        !            67:
        !            68: dnl  Usage: m68k_defreg(r)
        !            69: define(m68k_defreg,
        !            70: m4_assert_numargs(1)
        !            71: `deflit($1,`m68k_reg(`$1')')')
        !            72:
        !            73: m68k_defreg(d0)
        !            74: m68k_defreg(d1)
        !            75: m68k_defreg(d2)
        !            76: m68k_defreg(d3)
        !            77: m68k_defreg(d4)
        !            78: m68k_defreg(d5)
        !            79: m68k_defreg(d6)
        !            80: m68k_defreg(d7)
        !            81:
        !            82: m68k_defreg(a0)
        !            83: m68k_defreg(a1)
        !            84: m68k_defreg(a2)
        !            85: m68k_defreg(a3)
        !            86: m68k_defreg(a4)
        !            87: m68k_defreg(a5)
        !            88: m68k_defreg(a6)
        !            89: m68k_defreg(a7)
        !            90:
        !            91: m68k_defreg(sp)
        !            92: m68k_defreg(pc)
        !            93:
        !            94:
        !            95: dnl  Usage: M(base)
        !            96: dnl         M(base,displacement)
        !            97: dnl         M(base,index,size)
        !            98: dnl         M(base,index,size,scale)
        !            99: dnl         M(base,+)
        !           100: dnl         M(-,base)
        !           101: dnl
        !           102: dnl  `base' is an address register, `index' is a data register, `size' is w
        !           103: dnl  or l, and scale is 1, 2, 4 or 8.
        !           104: dnl
        !           105: dnl  M(-,base) has it's arguments that way around to emphasise it's a
        !           106: dnl  pre-decrement, as opposed to M(base,+) a post-increment.
        !           107: dnl
        !           108: dnl  Enhancement: Add the memory indirect modes, if/when they're needed.
        !           109:
        !           110: define(M,
        !           111: m4_assert_numargs_range(1,4)
        !           112: m4_assert_defined(`WANT_ADDRESSING')
        !           113: `ifelse(WANT_ADDRESSING,mit,
        !           114: `ifelse($#,1, ``$1'@')dnl
        !           115: ifelse($#,2,
        !           116: `ifelse($2,+, ``$1'@+',
        !           117: `ifelse($1,-, ``$2'@-',
        !           118:               ``$1'@($2)')')')dnl
        !           119: ifelse($#,3,  ``$1'@(`$2':`$3')')dnl
        !           120: ifelse($#,4,  ``$1'@(`$2':`$3':$4)')',
        !           121:
        !           122: dnl  WANT_ADDRESSING `motorola'
        !           123: `ifelse($#,1, `(`$1')')dnl
        !           124: ifelse($#,2,
        !           125: `ifelse($2,+, `(`$1')+',
        !           126: `ifelse($1,-, `-(`$2')',
        !           127:               `$2(`$1')')')')dnl
        !           128: ifelse($#,3,  `(`$1',`$2'.$3)')dnl
        !           129: ifelse($#,4,  `(`$1',`$2'.$3*$4)')')')
        !           130:
        !           131:
        !           132: dnl  Usage: addl etc
        !           133: dnl
        !           134: dnl  m68k instructions with special handling for the suffix, with for
        !           135: dnl  instance addl expanding to addl or add.l as necessary.
        !           136: dnl
        !           137: dnl  See also t-m68k-defs.pl which verifies all mnemonics used in the asm
        !           138: dnl  files have entries here.
        !           139:
        !           140: dnl  Called: m68k_insn(mnemonic,suffix)
        !           141: define(m68k_insn,
        !           142: m4_assert_numargs(2)
        !           143: m4_assert_defined(`WANT_DOT_SIZE')
        !           144: `ifelse(WANT_DOT_SIZE,yes, ``$1'.``$2''',
        !           145:                            ``$1$2'')')
        !           146:
        !           147: dnl  Usage: m68k_definsn(mnemonic,suffix)
        !           148: define(m68k_definsn,
        !           149: m4_assert_numargs(2)
        !           150: `deflit($1`'$2,`m68k_insn(`$1',`$2')')')
        !           151:
        !           152: m68k_definsn(add,  l)
        !           153: m68k_definsn(addx, l)
        !           154: m68k_definsn(addq, l)
        !           155: m68k_definsn(asl,  l)
        !           156: m68k_definsn(cmp,  l)
        !           157: m68k_definsn(clr,  l)
        !           158: m68k_definsn(divu, l)
        !           159: m68k_definsn(eor,  w)
        !           160: m68k_definsn(lsl,  l)
        !           161: m68k_definsn(lsr,  l)
        !           162: m68k_definsn(move, l)
        !           163: m68k_definsn(movem,l)
        !           164: m68k_definsn(moveq,l)
        !           165: m68k_definsn(mulu, l)
        !           166: m68k_definsn(neg,  l)
        !           167: m68k_definsn(or,   l)
        !           168: m68k_definsn(roxl, l)
        !           169: m68k_definsn(roxr, l)
        !           170: m68k_definsn(sub,  l)
        !           171: m68k_definsn(subx, l)
        !           172: m68k_definsn(subq, l)
        !           173:
        !           174:
        !           175: dnl  Usage: bra etc
        !           176: dnl
        !           177: dnl  Expand to `bra', `jra' or `jbra' according to what the assembler will
        !           178: dnl  accept.  The latter two give variable-sized branches in gas.
        !           179: dnl
        !           180: dnl  See also t-m68k-defs.pl which verifies all the bXX branches used in the
        !           181: dnl  asm files have entries here.
        !           182:
        !           183: dnl  Called: m68k_branch(cond)
        !           184: define(m68k_branch,
        !           185: m4_assert_numargs(1)
        !           186: m4_assert_defined(`WANT_BRANCHES')
        !           187: `ifelse(WANT_BRANCHES,jra, `j$1',
        !           188: `ifelse(WANT_BRANCHES,jbra,`jb$1',
        !           189:                            ``b$1'')')')
        !           190:
        !           191: dnl  Called: m68k_defbranch(cond)
        !           192: define(m68k_defbranch,
        !           193: m4_assert_numargs(1)
        !           194: `deflit(b$1,`m68k_branch(`$1')')')
        !           195:
        !           196: m68k_defbranch(ra)
        !           197: m68k_defbranch(cc)
        !           198: m68k_defbranch(cs)
        !           199: m68k_defbranch(ls)
        !           200: m68k_defbranch(eq)
        !           201: m68k_defbranch(ne)
        !           202:
        !           203:
        !           204: dnl  Usage: scale_available_p
        !           205: dnl
        !           206: dnl  Expand to 1 if a scale factor can be used in addressing modes, or 0 if
        !           207: dnl  not.  M(a0,d0,l,4), meaning a0+d0*4, is not available in 68000 or
        !           208: dnl  68010, but is in CPU32 and in 68020 and up.
        !           209:
        !           210: define(scale_available_p,
        !           211: `m4_ifdef_anyof_p(
        !           212: `HAVE_HOST_CPU_m68360'
        !           213: `HAVE_HOST_CPU_m68020'
        !           214: `HAVE_HOST_CPU_m68030'
        !           215: `HAVE_HOST_CPU_m68040'
        !           216: `HAVE_HOST_CPU_m68060')')
        !           217:
        !           218:
        !           219: divert

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>