Annotation of OpenXM_contrib/gmp/mpn/asm-defs.m4, Revision 1.1
1.1 ! maekawa 1: divert(-1)
! 2: dnl
! 3: dnl m4 macros for gmp assembly code, shared by all CPUs.
! 4: dnl
! 5: dnl These macros are designed for use with any m4 and have been used on
! 6: dnl GNU, FreeBSD, OpenBSD and SysV.
! 7: dnl
! 8: dnl GNU m4 and OpenBSD 2.7 m4 will give filenames and line numbers in error
! 9: dnl messages.
! 10:
! 11:
! 12: dnl Copyright (C) 1999, 2000 Free Software Foundation, Inc.
! 13: dnl
! 14: dnl This file is part of the GNU MP Library.
! 15: dnl
! 16: dnl The GNU MP Library is free software; you can redistribute it and/or
! 17: dnl modify it under the terms of the GNU Lesser General Public License as
! 18: dnl published by the Free Software Foundation; either version 2.1 of the
! 19: dnl License, or (at your option) any later version.
! 20: dnl
! 21: dnl The GNU MP Library is distributed in the hope that it will be useful,
! 22: dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
! 23: dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 24: dnl Lesser General Public License for more details.
! 25: dnl
! 26: dnl You should have received a copy of the GNU Lesser General Public
! 27: dnl License along with the GNU MP Library; see the file COPYING.LIB. If
! 28: dnl not, write to the Free Software Foundation, Inc., 59 Temple Place -
! 29: dnl Suite 330, Boston, MA 02111-1307, USA.
! 30:
! 31:
! 32: dnl Macros:
! 33: dnl
! 34: dnl Most new m4 specific macros have an "m4_" prefix to emphasise they're
! 35: dnl m4 expansions. But new defining things like deflit() and defreg() are
! 36: dnl named like the builtin define(), and forloop() is named following the
! 37: dnl GNU m4 example on which it's based.
! 38: dnl
! 39: dnl GNU m4 with the -P option uses "m4_" as a prefix for builtins, but that
! 40: dnl option isn't going to be used, so there's no conflict or confusion.
! 41: dnl
! 42: dnl
! 43: dnl Comments in output:
! 44: dnl
! 45: dnl The m4 comment delimiters are left at # and \n, the normal assembler
! 46: dnl commenting for most CPUs. m4 passes comment text through without
! 47: dnl expanding macros in it, which is generally a good thing since it stops
! 48: dnl unexpected expansions and possible resultant errors.
! 49: dnl
! 50: dnl But note that when a quoted string is being read, a # isn't special, so
! 51: dnl apostrophes in comments in quoted strings must be avoided or they'll be
! 52: dnl interpreted as a closing quote mark. But when the quoted text is
! 53: dnl re-read # will still act like a normal comment, supressing macro
! 54: dnl expansion.
! 55: dnl
! 56: dnl For example,
! 57: dnl
! 58: dnl # apostrophes in comments that're outside quotes are ok
! 59: dnl # and using macro names like PROLOGUE is ok too
! 60: dnl ...
! 61: dnl ifdef(`PIC',`
! 62: dnl # but apostrophes aren't ok inside quotes
! 63: dnl # ^--wrong
! 64: dnl ...
! 65: dnl # though macro names like PROLOGUE are still ok
! 66: dnl ...
! 67: dnl ')
! 68: dnl
! 69: dnl If macro expansion in a comment is wanted, use `#' in the .asm (ie. a
! 70: dnl quoted hash symbol), which will turn into # in the .s but get
! 71: dnl expansions done on that line. This can make the .s more readable to
! 72: dnl humans, but it won't make a blind bit of difference to the assembler.
! 73: dnl
! 74: dnl All the above applies, mutatis mutandis, when changecom() is used to
! 75: dnl select @ ! ; or whatever other commenting.
! 76: dnl
! 77: dnl
! 78: dnl Variations in m4 affecting gmp:
! 79: dnl
! 80: dnl $# - When a macro is called as "foo" with no brackets, BSD m4 sets $#
! 81: dnl to 1, whereas GNU or SysV m4 set it to 0. In all cases though
! 82: dnl "foo()" sets $# to 1. This is worked around in various places.
! 83: dnl
! 84: dnl len() - When "len()" is given an empty argument, BSD m4 evaluates to
! 85: dnl nothing, whereas GNU, SysV, and the new OpenBSD, evaluate to 0.
! 86: dnl See m4_length() below which works around this.
! 87: dnl
! 88: dnl translit() - GNU m4 accepts character ranges like A-Z, and the new
! 89: dnl OpenBSD m4 does under option -g, but basic BSD and SysV don't.
! 90: dnl
! 91: dnl popdef() - in BSD and SysV m4 popdef() takes multiple arguments and
! 92: dnl pops each, but GNU m4 only takes one argument.
! 93: dnl
! 94: dnl push back - BSD m4 has some limits on the amount of text that can be
! 95: dnl pushed back. The limit is reasonably big and so long as macros
! 96: dnl don't gratuitously duplicate big arguments it isn't a problem.
! 97: dnl Normally an error message is given, but sometimes it just hangs.
! 98: dnl
! 99: dnl eval() &,|,^ - GNU and SysV m4 have bitwise operators &,|,^ available,
! 100: dnl but BSD m4 doesn't (contrary to what the man page suggests) and
! 101: dnl instead ^ is exponentiation.
! 102: dnl
! 103: dnl eval() ?: - The C ternary operator "?:" is available in BSD m4, but not
! 104: dnl in SysV or GNU m4 (as of GNU m4 1.4 and betas of 1.5).
! 105: dnl
! 106: dnl eval() -2^31 - BSD m4 has a bug where an eval() resulting in -2^31
! 107: dnl (ie. -2147483648) gives "-(". Using -2147483648 within an
! 108: dnl expression is ok, it just can't be a final result. "-(" will of
! 109: dnl course upset parsing, with all sorts of strange effects.
! 110: dnl
! 111: dnl eval() <<,>> - SysV m4 doesn't support shift operators in eval() (on
! 112: dnl SunOS 5.7 /usr/xpg4/m4 has them but /usr/ccs/m4 doesn't). See
! 113: dnl m4_lshift() and m4_rshift() below for workarounds.
! 114: dnl
! 115: dnl m4wrap() - in BSD m4, m4wrap() replaces any previous m4wrap() string,
! 116: dnl in SysV m4 it appends to it, and in GNU m4 it prepends. See
! 117: dnl m4wrap_prepend() below which brings uniformity to this.
! 118: dnl
! 119: dnl __file__,__line__ - GNU m4 and OpenBSD 2.7 m4 provide these, and
! 120: dnl they're used here to make error messages more informative. GNU m4
! 121: dnl gives an unhelpful "NONE 0" in an m4wrap(), but that's worked
! 122: dnl around.
! 123: dnl
! 124: dnl __file__ quoting - OpenBSD m4, unlike GNU m4, doesn't quote the
! 125: dnl filename in __file__, so care should be taken that no macro has
! 126: dnl the same name as a file, or an unwanted expansion will occur when
! 127: dnl printing an error or warning.
! 128: dnl
! 129: dnl OpenBSD 2.6 m4 - this m4 rejects decimal constants containing an 8 or 9
! 130: dnl in eval(), making it pretty much unusable. This bug is confined
! 131: dnl to version 2.6 (it's not in 2.5, and has been fixed in 2.7).
! 132: dnl
! 133: dnl SunOS /usr/bin/m4 - this m4 lacks a number of desired features,
! 134: dnl including $# and $@, defn(), m4exit(), m4wrap(), pushdef(),
! 135: dnl popdef(). /usr/5bin/m4 is a SysV style m4 which should always be
! 136: dnl available, and "configure" will reject /usr/bin/m4 in favour of
! 137: dnl /usr/5bin/m4 (if necessary).
! 138: dnl
! 139: dnl The sparc code actually has modest m4 requirements currently and
! 140: dnl could manage with /usr/bin/m4, but there's no reason to put our
! 141: dnl macros through contortions when /usr/5bin/m4 is available or GNU
! 142: dnl m4 can be installed.
! 143:
! 144:
! 145: ifdef(`__ASM_DEFS_M4_INCLUDED__',
! 146: `m4_error(`asm-defs.m4 already included, dont include it twice
! 147: ')m4exit(1)')
! 148: define(`__ASM_DEFS_M4_INCLUDED__')
! 149:
! 150:
! 151: dnl Detect and give a message about the unsuitable OpenBSD 2.6 m4.
! 152:
! 153: ifelse(eval(89),89,,
! 154: `errprint(
! 155: `This m4 doesnt accept 8 and/or 9 in constants in eval(), making it unusable.
! 156: This is probably OpenBSD 2.6 m4 (September 1999). Upgrade to OpenBSD 2.7,
! 157: or get a bug fix from the CVS (expr.c rev 1.9), or get GNU m4. Dont forget
! 158: to configure with M4=/wherever/m4 if you install one of these in a directory
! 159: not in $PATH.
! 160: ')m4exit(1)')
! 161:
! 162:
! 163: dnl Detect and give a message about the unsuitable SunOS /usr/bin/m4.
! 164: dnl
! 165: dnl Unfortunately this test doesn't work when m4 is run in the normal way
! 166: dnl from mpn/Makefile with "m4 -DOPERATION_foo foo.asm", since the bad m4
! 167: dnl takes "-" in "-D..." to mean read stdin, so it will look like it just
! 168: dnl hangs. But running "m4 asm-defs.m4" to try it out will work.
! 169: dnl
! 170: dnl We'd like to abort immediately on finding a problem, but unfortunately
! 171: dnl the bad m4 doesn't have an m4exit(), nor does an invalid eval() kill
! 172: dnl it. Unexpanded $#'s in some m4_assert_numargs() later on will comment
! 173: dnl out some closing parentheses and kill it with "m4: arg stack overflow".
! 174:
! 175: define(m4_dollarhash_works_test,``$#'')
! 176: ifelse(m4_dollarhash_works_test(x),1,,
! 177: `errprint(
! 178: `This m4 doesnt support $# and cant be used for GMP asm processing.
! 179: If this is on SunOS, ./configure should choose /usr/5bin/m4 if you have that
! 180: or can get it, otherwise install GNU m4. Dont forget to configure with
! 181: M4=/wherever/m4 if you install in a directory not in $PATH.
! 182: ')')
! 183: undefine(`m4_dollarhash_works_test')
! 184:
! 185:
! 186: dnl --------------------------------------------------------------------------
! 187: dnl Basic error handling things.
! 188:
! 189:
! 190: dnl Usage: m4_dollarhash_1_if_noparen_p
! 191: dnl
! 192: dnl Expand to 1 if a call "foo" gives $# set to 1 (as opposed to 0 like GNU
! 193: dnl and SysV m4 give).
! 194:
! 195: define(m4_dollarhash_1_if_noparen_test,`$#')
! 196: define(m4_dollarhash_1_if_noparen_p,
! 197: eval(m4_dollarhash_1_if_noparen_test==1))
! 198: undefine(`m4_dollarhash_1_if_noparen_test')
! 199:
! 200:
! 201: dnl Usage: m4wrap_prepend(string)
! 202: dnl
! 203: dnl Prepend the given string to what will be exapanded under m4wrap at the
! 204: dnl end of input.
! 205: dnl
! 206: dnl This macro exists to work around variations in m4wrap() behaviour in
! 207: dnl the various m4s (notes at the start of this file). Don't use m4wrap()
! 208: dnl directly since it will interfere with this scheme.
! 209:
! 210: define(m4wrap_prepend,
! 211: m4_assert_numargs(1)
! 212: `define(`m4wrap_string',`$1'defn(`m4wrap_string'))')
! 213:
! 214: m4wrap(`m4wrap_string')
! 215: define(m4wrap_string,`')
! 216:
! 217:
! 218: dnl Usage: m4_file_and_line
! 219: dnl
! 220: dnl Expand to the current file and line number, if the GNU m4 extensions
! 221: dnl __file__ and __line__ are available.
! 222: dnl
! 223: dnl In GNU m4 1.4 at the end of input when m4wrap text is expanded,
! 224: dnl __file__ is NONE and __line__ is 0, which is not a helpful thing to
! 225: dnl print. If m4_file_seen() has been called to note the last file seen,
! 226: dnl then that file at a big line number is used, otherwise "end of input"
! 227: dnl is used (although "end of input" won't parse as an error message).
! 228:
! 229: define(m4_file_and_line,
! 230: `ifdef(`__file__',
! 231: `ifelse(__file__`'__line__,`NONE0',
! 232: `ifdef(`m4_file_seen_last',`m4_file_seen_last: 999999: ',`end of input: ')',
! 233: `__file__: __line__: ')')')
! 234:
! 235:
! 236: dnl Usage: m4_errprint_commas(arg,...)
! 237: dnl
! 238: dnl The same as errprint(), but commas are printed between arguments
! 239: dnl instead of spaces.
! 240:
! 241: define(m4_errprint_commas,
! 242: `errprint(`$1')dnl
! 243: ifelse(eval($#>1),1,`errprint(`,')m4_errprint_commas(shift($@))')')
! 244:
! 245:
! 246: dnl Usage: m4_error(args...)
! 247: dnl m4_warning(args...)
! 248: dnl
! 249: dnl Print an error message, using m4_errprint_commas, prefixed with the
! 250: dnl current filename and line number (if available). m4_error sets up to
! 251: dnl give an error exit at the end of processing, m4_warning just prints.
! 252: dnl These macros are the recommended way to print errors.
! 253: dnl
! 254: dnl The arguments here should be quoted in the usual way to prevent them
! 255: dnl being expanded when the macro call is read. (m4_error takes care not
! 256: dnl to do any further expansion.)
! 257: dnl
! 258: dnl For example,
! 259: dnl
! 260: dnl m4_error(`some error message
! 261: dnl ')
! 262: dnl
! 263: dnl which prints
! 264: dnl
! 265: dnl foo.asm:123: some error message
! 266: dnl
! 267: dnl or if __file__ and __line__ aren't available
! 268: dnl
! 269: dnl some error message
! 270: dnl
! 271: dnl The "file:line:" format is a basic style, used by gcc and GNU m4, so
! 272: dnl emacs and other editors will recognise it in their normal error message
! 273: dnl parsing.
! 274:
! 275: define(m4_warning,
! 276: `m4_errprint_commas(m4_file_and_line`'$@)')
! 277:
! 278: define(m4_error,
! 279: `define(`m4_error_occurred',1)m4_warning($@)')
! 280:
! 281: define(`m4_error_occurred',0)
! 282:
! 283: dnl This m4wrap_prepend() is first, so it'll be executed last.
! 284: m4wrap_prepend(
! 285: `ifelse(m4_error_occurred,1,
! 286: `m4_error(`Errors occurred during m4 processing
! 287: ')m4exit(1)')')
! 288:
! 289:
! 290: dnl Usage: m4_assert_numargs(num)
! 291: dnl
! 292: dnl Put this unquoted on a line on its own at the start of a macro
! 293: dnl definition to add some code to check that num many arguments get passed
! 294: dnl to the macro. For example,
! 295: dnl
! 296: dnl define(foo,
! 297: dnl m4_assert_numargs(2)
! 298: dnl `something `$1' and `$2' blah blah')
! 299: dnl
! 300: dnl Then a call like foo(one,two,three) will provoke an error like
! 301: dnl
! 302: dnl file:10: foo expected 2 arguments, got 3 arguments
! 303: dnl
! 304: dnl Here are some calls and how many arguments they're interpreted as passing.
! 305: dnl
! 306: dnl foo(abc,def) 2
! 307: dnl foo(xyz) 1
! 308: dnl foo() 0
! 309: dnl foo -1
! 310: dnl
! 311: dnl The -1 for no parentheses at all means a macro that's meant to be used
! 312: dnl that way can be checked with m4_assert_numargs(-1). For example,
! 313: dnl
! 314: dnl define(SPECIAL_SUFFIX,
! 315: dnl m4_assert_numargs(-1)
! 316: dnl `ifdef(`FOO',`_foo',`_bar')')
! 317: dnl
! 318: dnl But as an alternative see also deflit() below where parenthesized
! 319: dnl expressions following a macro are passed through to the output.
! 320: dnl
! 321: dnl Note that in BSD m4 there's no way to differentiate calls "foo" and
! 322: dnl "foo()", so in BSD m4 the distinction between the two isn't enforced.
! 323: dnl (In GNU and SysV m4 it can be checked, and is.)
! 324:
! 325:
! 326: dnl m4_assert_numargs is able to check its own arguments by calling
! 327: dnl assert_numargs_internal directly.
! 328: dnl
! 329: dnl m4_doublequote($`'0) expands to ``$0'', whereas ``$`'0'' would expand
! 330: dnl to `$`'0' and do the wrong thing, and likewise for $1. The same is
! 331: dnl done in other assert macros.
! 332: dnl
! 333: dnl $`#' leaves $# in the new macro being defined, and stops # being
! 334: dnl interpreted as a comment character.
! 335: dnl
! 336: dnl `dnl ' means an explicit dnl isn't necessary when m4_assert_numargs is
! 337: dnl used. The space means that if there is a dnl it'll still work.
! 338:
! 339: dnl Usage: m4_doublequote(x) expands to ``x''
! 340: define(m4_doublequote,
! 341: `m4_assert_numargs_internal(`$0',1,$#,len(`$1'))``$1''')
! 342:
! 343: define(m4_assert_numargs,
! 344: `m4_assert_numargs_internal(`$0',1,$#,len(`$1'))dnl
! 345: `m4_assert_numargs_internal'(m4_doublequote($`'0),$1,$`#',`len'(m4_doublequote($`'1)))`dnl '')
! 346:
! 347: dnl Called: m4_assert_numargs_internal(`macroname',wantargs,$#,len(`$1'))
! 348: define(m4_assert_numargs_internal,
! 349: `m4_assert_numargs_internal_check(`$1',`$2',m4_numargs_count(`$3',`$4'))')
! 350:
! 351: dnl Called: m4_assert_numargs_internal_check(`macroname',wantargs,gotargs)
! 352: dnl
! 353: dnl If m4_dollarhash_1_if_noparen_p (BSD m4) then gotargs can be 0 when it
! 354: dnl should be -1. If wantargs is -1 but gotargs is 0 and the two can't be
! 355: dnl distinguished then it's allowed to pass.
! 356: dnl
! 357: define(m4_assert_numargs_internal_check,
! 358: `ifelse(eval($2 == $3
! 359: || ($2==-1 && $3==0 && m4_dollarhash_1_if_noparen_p)),0,
! 360: `m4_error(`$1 expected 'm4_Narguments(`$2')`, got 'm4_Narguments(`$3')
! 361: )')')
! 362:
! 363: dnl Called: m4_numargs_count($#,len(`$1'))
! 364: dnl If $#==0 then -1 args, if $#==1 but len(`$1')==0 then 0 args, otherwise
! 365: dnl $# args.
! 366: define(m4_numargs_count,
! 367: `ifelse($1,0, -1,
! 368: `ifelse(eval($1==1 && $2-0==0),1, 0, $1)')')
! 369:
! 370: dnl Usage: m4_Narguments(N)
! 371: dnl "$1 argument" or "$1 arguments" with the plural according to $1.
! 372: define(m4_Narguments,
! 373: `$1 argument`'ifelse(`$1',1,,s)')
! 374:
! 375:
! 376: dnl --------------------------------------------------------------------------
! 377: dnl Additional error checking things.
! 378:
! 379:
! 380: dnl Usage: m4_file_seen()
! 381: dnl
! 382: dnl Record __file__ for the benefit of m4_file_and_line in m4wrap text.
! 383: dnl The basic __file__ macro comes out quoted, like `foo.asm', and
! 384: dnl m4_file_seen_last is defined like that too.
! 385: dnl
! 386: dnl This only needs to be used with something that could generate an error
! 387: dnl message in m4wrap text. The x86 PROLOGUE is the only such at the
! 388: dnl moment (at end of input its m4wrap checks for missing EPILOGUE). A few
! 389: dnl include()s can easily trick this scheme, but you'd expect an EPILOGUE
! 390: dnl in the same file as the PROLOGUE.
! 391:
! 392: define(m4_file_seen,
! 393: m4_assert_numargs(0)
! 394: `ifelse(__file__,`NONE',,
! 395: `define(`m4_file_seen_last',m4_doublequote(__file__))')')
! 396:
! 397:
! 398: dnl Usage: m4_assert_onearg()
! 399: dnl
! 400: dnl Put this, unquoted, at the start of a macro definition to add some code
! 401: dnl to check that one argument is passed to the macro, but with that
! 402: dnl argument allowed to be empty. For example,
! 403: dnl
! 404: dnl define(foo,
! 405: dnl m4_assert_onearg()
! 406: dnl `blah blah $1 blah blah')
! 407: dnl
! 408: dnl Calls "foo(xyz)" or "foo()" are accepted. A call "foo(xyz,abc)" fails.
! 409: dnl A call "foo" fails too, but BSD m4 can't detect this case (GNU and SysV
! 410: dnl m4 can).
! 411:
! 412: define(m4_assert_onearg,
! 413: m4_assert_numargs(0)
! 414: `m4_assert_onearg_internal'(m4_doublequote($`'0),$`#')`dnl ')
! 415:
! 416: dnl Called: m4_assert_onearg(`macroname',$#)
! 417: define(m4_assert_onearg_internal,
! 418: `ifelse($2,1,,
! 419: `m4_error(`$1 expected 1 argument, got 'm4_Narguments(`$2')
! 420: )')')
! 421:
! 422:
! 423: dnl Usage: m4_assert_numargs_range(low,high)
! 424: dnl
! 425: dnl Put this, unquoted, at the start of a macro definition to add some code
! 426: dnl to check that between low and high many arguments get passed to the
! 427: dnl macro. For example,
! 428: dnl
! 429: dnl define(foo,
! 430: dnl m4_assert_numargs_range(3,5)
! 431: dnl `mandatory $1 $2 $3 optional $4 $5 end')
! 432: dnl
! 433: dnl See m4_assert_numargs() for more info.
! 434:
! 435: define(m4_assert_numargs_range,
! 436: m4_assert_numargs(2)
! 437: ``m4_assert_numargs_range_internal'(m4_doublequote($`'0),$1,$2,$`#',`len'(m4_doublequote($`'1)))`dnl '')
! 438:
! 439: dnl Called: m4_assert_numargs_range_internal(`name',low,high,$#,len(`$1'))
! 440: define(m4_assert_numargs_range_internal,
! 441: m4_assert_numargs(5)
! 442: `m4_assert_numargs_range_check(`$1',`$2',`$3',m4_numargs_count(`$4',`$5'))')
! 443:
! 444: dnl Called: m4_assert_numargs_range_check(`name',low,high,gotargs)
! 445: dnl
! 446: dnl If m4_dollarhash_1_if_noparen_p (BSD m4) then gotargs can be 0 when it
! 447: dnl should be -1. To ensure a `high' of -1 works, a fudge is applied to
! 448: dnl gotargs if it's 0 and the 0 and -1 cases can't be distinguished.
! 449: dnl
! 450: define(m4_assert_numargs_range_check,
! 451: m4_assert_numargs(4)
! 452: `ifelse(eval($2 <= $4 &&
! 453: ($4 - ($4==0 && m4_dollarhash_1_if_noparen_p) <= $3)),0,
! 454: `m4_error(`$1 expected $2 to $3 arguments, got 'm4_Narguments(`$4')
! 455: )')')
! 456:
! 457:
! 458: dnl Usage: m4_assert_defined(symbol)
! 459: dnl
! 460: dnl Put this unquoted on a line of its own at the start of a macro
! 461: dnl definition to add some code to check that the given symbol is defined
! 462: dnl when the macro is used. For example,
! 463: dnl
! 464: dnl define(foo,
! 465: dnl m4_assert_defined(`FOO_PREFIX')
! 466: dnl `FOO_PREFIX whatever')
! 467: dnl
! 468: dnl This is a convenient way to check that the user or ./configure or
! 469: dnl whatever has defined the things needed by a macro, as opposed to
! 470: dnl silently generating garbage.
! 471:
! 472: define(m4_assert_defined,
! 473: m4_assert_numargs(1)
! 474: ``m4_assert_defined_internal'(m4_doublequote($`'0),``$1'')`dnl '')
! 475:
! 476: dnl Called: m4_assert_defined_internal(`macroname',`define_required')
! 477: define(m4_assert_defined_internal,
! 478: m4_assert_numargs(2)
! 479: `ifdef(`$2',,
! 480: `m4_error(`$1 needs $2 defined
! 481: ')')')
! 482:
! 483:
! 484: dnl Usage: m4_not_for_expansion(`SYMBOL')
! 485: dnl define_not_for_expansion(`SYMBOL')
! 486: dnl
! 487: dnl m4_not_for_expansion turns SYMBOL, if defined, into something which
! 488: dnl will give an error if expanded. For example,
! 489: dnl
! 490: dnl m4_not_for_expansion(`PIC')
! 491: dnl
! 492: dnl define_not_for_expansion is the same, but always makes a definition.
! 493: dnl
! 494: dnl These are for symbols that should be tested with ifdef(`FOO',...)
! 495: dnl rather than be expanded as such. They guard against accidentally
! 496: dnl omitting the quotes, as in ifdef(FOO,...). Note though that they only
! 497: dnl catches this when FOO is defined, so be sure to test code both with and
! 498: dnl without each definition.
! 499:
! 500: define(m4_not_for_expansion,
! 501: m4_assert_numargs(1)
! 502: `ifdef(`$1',`define_not_for_expansion(`$1')')')
! 503:
! 504: define(define_not_for_expansion,
! 505: m4_assert_numargs(1)
! 506: `ifelse(defn(`$1'),,,
! 507: `m4_error(``$1' has a non-empty value, maybe it shouldnt be munged with m4_not_for_expansion()
! 508: ')')dnl
! 509: define(`$1',`m4_not_for_expansion_internal(`$1')')')
! 510:
! 511: define(m4_not_for_expansion_internal,
! 512: `m4_error(``$1' is not meant to be expanded, perhaps you mean `ifdef(`$1',...)'
! 513: ')')
! 514:
! 515:
! 516: dnl --------------------------------------------------------------------------
! 517: dnl Various generic m4 things.
! 518:
! 519:
! 520: dnl Usage: m4_ifdef_anyof_p(`symbol',...)
! 521: dnl
! 522: dnl Expand to 1 if any of the symbols in the argument list are defined, or
! 523: dnl to 0 if not.
! 524:
! 525: define(m4_ifdef_anyof_p,
! 526: `ifelse(eval($#<=1 && m4_length(`$1')==0),1, 0,
! 527: `ifdef(`$1', 1,
! 528: `m4_ifdef_anyof_p(shift($@))')')')
! 529:
! 530:
! 531: dnl Usage: m4_length(string)
! 532: dnl
! 533: dnl Determine the length of a string. This is the same as len(), but
! 534: dnl always expands to a number, working around the BSD len() which
! 535: dnl evaluates to nothing given an empty argument.
! 536:
! 537: define(m4_length,
! 538: m4_assert_onearg()
! 539: `eval(len(`$1')-0)')
! 540:
! 541:
! 542: dnl Usage: m4_stringequal_p(x,y)
! 543: dnl
! 544: dnl Expand to 1 or 0 according as strings x and y are equal or not.
! 545:
! 546: define(m4_stringequal_p,
! 547: `ifelse(`$1',`$2',1,0)')
! 548:
! 549:
! 550: dnl Usage: m4_incr_or_decr(n,last)
! 551: dnl
! 552: dnl Do an incr(n) or decr(n), whichever is in the direction of "last".
! 553: dnl Both n and last must be numbers of course.
! 554:
! 555: define(m4_incr_or_decr,
! 556: m4_assert_numargs(2)
! 557: `ifelse(eval($1<$2),1,incr($1),decr($1))')
! 558:
! 559:
! 560: dnl Usage: forloop(i, first, last, statement)
! 561: dnl
! 562: dnl Based on GNU m4 examples/forloop.m4, but extended.
! 563: dnl
! 564: dnl statement is expanded repeatedly, with i successively defined as
! 565: dnl
! 566: dnl first, first+1, ..., last-1, last
! 567: dnl
! 568: dnl Or if first > last, then it's
! 569: dnl
! 570: dnl first, first-1, ..., last+1, last
! 571: dnl
! 572: dnl If first == last, then one expansion is done.
! 573: dnl
! 574: dnl A pushdef/popdef of i is done to preserve any previous definition (or
! 575: dnl lack of definition). first and last are eval()ed and so can be
! 576: dnl expressions.
! 577: dnl
! 578: dnl forloop_first is defined to 1 on the first iteration, 0 on the rest.
! 579: dnl forloop_last is defined to 1 on the last iteration, 0 on the others.
! 580: dnl Nested forloops are allowed, in which case forloop_first and
! 581: dnl forloop_last apply to the innermost loop that's open.
! 582: dnl
! 583: dnl A simple example,
! 584: dnl
! 585: dnl forloop(i, 1, 2*2+1, `dnl
! 586: dnl iteration number i ... ifelse(forloop_first,1,FIRST)
! 587: dnl ')
! 588:
! 589:
! 590: dnl "i" and "statement" are carefully quoted, but "first" and "last" are
! 591: dnl just plain numbers once eval()ed.
! 592:
! 593: define(`forloop',
! 594: m4_assert_numargs(4)
! 595: `pushdef(`$1',eval(`$2'))dnl
! 596: pushdef(`forloop_first',1)dnl
! 597: pushdef(`forloop_last',0)dnl
! 598: forloop_internal(`$1',eval(`$3'),`$4')`'dnl
! 599: popdef(`forloop_first')dnl
! 600: popdef(`forloop_last')dnl
! 601: popdef(`$1')')
! 602:
! 603: dnl Called: forloop_internal(`var',last,statement)
! 604: define(`forloop_internal',
! 605: m4_assert_numargs(3)
! 606: `ifelse($1,$2,
! 607: `define(`forloop_last',1)$3',
! 608: `$3`'dnl
! 609: define(`forloop_first',0)dnl
! 610: define(`$1',m4_incr_or_decr($1,$2))dnl
! 611: forloop_internal(`$1',$2,`$3')')')
! 612:
! 613:
! 614: dnl Usage: m4_toupper(x)
! 615: dnl m4_tolower(x)
! 616: dnl
! 617: dnl Convert the argument string to upper or lower case, respectively.
! 618: dnl Only one argument accepted.
! 619: dnl
! 620: dnl BSD m4 doesn't take ranges like a-z in translit(), so the full alphabet
! 621: dnl is written out.
! 622:
! 623: define(m4_alphabet_lower, `abcdefghijklmnopqrstuvwxyz')
! 624: define(m4_alphabet_upper, `ABCDEFGHIJKLMNOPQRSTUVWXYZ')
! 625:
! 626: define(m4_toupper,
! 627: m4_assert_onearg()
! 628: `translit(`$1', m4_alphabet_lower, m4_alphabet_upper)')
! 629:
! 630: define(m4_tolower,
! 631: m4_assert_onearg()
! 632: `translit(`$1', m4_alphabet_upper, m4_alphabet_lower)')
! 633:
! 634:
! 635: dnl Usage: m4_empty_if_zero(x)
! 636: dnl
! 637: dnl Evaluate to x, or to nothing if x is 0. x is eval()ed and so can be an
! 638: dnl expression.
! 639: dnl
! 640: dnl This is useful for x86 addressing mode displacements since forms like
! 641: dnl (%ebx) are one byte shorter than 0(%ebx). A macro `foo' for use as
! 642: dnl foo(%ebx) could be defined with the following so it'll be empty if the
! 643: dnl expression comes out zero.
! 644: dnl
! 645: dnl deflit(`foo', `m4_empty_if_zero(a+b*4-c)')
! 646: dnl
! 647: dnl Naturally this shouldn't be done if, say, a computed jump depends on
! 648: dnl the code being a particular size.
! 649:
! 650: define(m4_empty_if_zero,
! 651: m4_assert_onearg()
! 652: `ifelse(eval($1),0,,eval($1))')
! 653:
! 654:
! 655: dnl Usage: m4_log2(x)
! 656: dnl
! 657: dnl Calculate a logarithm to base 2.
! 658: dnl x must be an integral power of 2, between 2**0 and 2**30.
! 659: dnl x is eval()ed, so it can be an expression.
! 660: dnl An error results if x is invalid.
! 661: dnl
! 662: dnl 2**31 isn't supported, because an unsigned 2147483648 is out of range
! 663: dnl of a 32-bit signed int. Also, the bug in BSD m4 where an eval()
! 664: dnl resulting in 2147483648 (or -2147483648 as the case may be) gives `-('
! 665: dnl means tests like eval(1<<31==(x)) would be necessary, but that then
! 666: dnl gives an unattractive explosion of eval() error messages if x isn't
! 667: dnl numeric.
! 668:
! 669: define(m4_log2,
! 670: m4_assert_numargs(1)
! 671: `m4_log2_internal(0,1,eval(`$1'))')
! 672:
! 673: dnl Called: m4_log2_internal(n,2**n,target)
! 674: define(m4_log2_internal,
! 675: m4_assert_numargs(3)
! 676: `ifelse($2,$3,$1,
! 677: `ifelse($1,30,
! 678: `m4_error(`m4_log2() argument too big or not a power of two: $3
! 679: ')',
! 680: `m4_log2_internal(incr($1),eval(2*$2),$3)')')')
! 681:
! 682:
! 683: dnl Usage: m4_div2_towards_zero
! 684: dnl
! 685: dnl m4 division is probably whatever a C signed division is, and C doesn't
! 686: dnl specify what rounding gets used on negatives, so this expression forces
! 687: dnl a rounding towards zero.
! 688:
! 689: define(m4_div2_towards_zero,
! 690: m4_assert_numargs(1)
! 691: `eval((($1) + ((($1)<0) & ($1))) / 2)')
! 692:
! 693:
! 694: dnl Usage: m4_lshift(n,count)
! 695: dnl m4_rshift(n,count)
! 696: dnl
! 697: dnl Calculate n shifted left or right by count many bits. Both n and count
! 698: dnl are eval()ed and so can be expressions.
! 699: dnl
! 700: dnl Negative counts are allowed and mean a shift in the opposite direction.
! 701: dnl Negative n is allowed and right shifts will be arithmetic (meaning
! 702: dnl divide by 2**count, rounding towards zero, also meaning the sign bit is
! 703: dnl duplicated).
! 704: dnl
! 705: dnl Use these macros instead of << and >> in eval() since the basic ccs
! 706: dnl SysV m4 doesn't have those operators.
! 707:
! 708: define(m4_rshift,
! 709: m4_assert_numargs(2)
! 710: `m4_lshift(`$1',-(`$2'))')
! 711:
! 712: define(m4_lshift,
! 713: m4_assert_numargs(2)
! 714: `m4_lshift_internal(eval(`$1'),eval(`$2'))')
! 715:
! 716: define(m4_lshift_internal,
! 717: m4_assert_numargs(2)
! 718: `ifelse(eval($2-0==0),1,$1,
! 719: `ifelse(eval($2>0),1,
! 720: `m4_lshift_internal(eval($1*2),decr($2))',
! 721: `m4_lshift_internal(m4_div2_towards_zero($1),incr($2))')')')
! 722:
! 723:
! 724: dnl Usage: deflit(name,value)
! 725: dnl
! 726: dnl Like define(), but "name" expands like a literal, rather than taking
! 727: dnl arguments. For example "name(%eax)" expands to "value(%eax)".
! 728: dnl
! 729: dnl Limitations:
! 730: dnl
! 731: dnl $ characters in the value part must have quotes to stop them looking
! 732: dnl like macro parameters. For example, deflit(reg,`123+$`'4+567'). See
! 733: dnl defreg() below for handling simple register definitions like $7 etc.
! 734: dnl
! 735: dnl "name()" is turned into "name", unfortunately. In GNU and SysV m4 an
! 736: dnl error is generated when this happens, but in BSD m4 it will happen
! 737: dnl silently. The problem is that in BSD m4 $# is 1 in both "name" or
! 738: dnl "name()", so there's no way to differentiate them. Because we want
! 739: dnl plain "name" to turn into plain "value", we end up with "name()"
! 740: dnl turning into plain "value" too.
! 741: dnl
! 742: dnl "name(foo)" will lose any whitespace after commas in "foo", for example
! 743: dnl "disp(%eax, %ecx)" would become "128(%eax,%ecx)".
! 744: dnl
! 745: dnl These parentheses oddities shouldn't matter in assembler text, but if
! 746: dnl they do the suggested workaround is to write "name ()" or "name (foo)"
! 747: dnl to stop the parentheses looking like a macro argument list. If a space
! 748: dnl isn't acceptable in the output, then write "name`'()" or "name`'(foo)".
! 749: dnl The `' is stripped when read, but again stops the parentheses looking
! 750: dnl like parameters.
! 751:
! 752: dnl Quoting for deflit_emptyargcheck is similar to m4_assert_numargs. The
! 753: dnl stuff in the ifelse gives a $#, $1 and $@ evaluated in the new macro
! 754: dnl created, not in deflit.
! 755: define(deflit,
! 756: m4_assert_numargs(2)
! 757: `define(`$1',
! 758: `deflit_emptyargcheck'(``$1'',$`#',m4_doublequote($`'1))`dnl
! 759: $2`'dnl
! 760: ifelse(eval($'`#>1 || m4_length('m4_doublequote($`'1)`)!=0),1,($'`@))')')
! 761:
! 762: dnl Called: deflit_emptyargcheck(macroname,$#,`$1')
! 763: define(deflit_emptyargcheck,
! 764: `ifelse(eval($2==1 && !m4_dollarhash_1_if_noparen_p && m4_length(`$3')==0),1,
! 765: `m4_error(`dont use a deflit as $1() because it loses the brackets (see deflit in asm-incl.m4 for more information)
! 766: ')')')
! 767:
! 768:
! 769: dnl Usage: m4_assert(`expr')
! 770: dnl
! 771: dnl Test a compile-time requirement with an m4 expression. The expression
! 772: dnl should be quoted, and will be eval()ed and expected to be non-zero.
! 773: dnl For example,
! 774: dnl
! 775: dnl m4_assert(`FOO*2+6 < 14')
! 776:
! 777: define(m4_assert,
! 778: m4_assert_numargs(1)
! 779: `ifelse(eval($1),1,,
! 780: `m4_error(`assertion failed: $1
! 781: ')')')
! 782:
! 783:
! 784: dnl --------------------------------------------------------------------------
! 785: dnl Various assembler things, not specific to any particular CPU.
! 786: dnl
! 787:
! 788:
! 789: dnl Usage: include_mpn(`filename')
! 790: dnl
! 791: dnl Like include(), but adds a path to the mpn source directory. For
! 792: dnl example,
! 793: dnl
! 794: dnl include_mpn(`sparc64/addmul_1h.asm')
! 795:
! 796: define(include_mpn,
! 797: m4_assert_numargs(1)
! 798: m4_assert_defined(`CONFIG_TOP_SRCDIR')
! 799: `include(CONFIG_TOP_SRCDIR`/mpn/$1')')
! 800:
! 801:
! 802: dnl Usage: C comment ...
! 803: dnl
! 804: dnl "C" works like a FORTRAN-style comment character. This can be used for
! 805: dnl comments to the right of assembly instructions, where just dnl would
! 806: dnl remove the linefeed, and concatenate adjacent lines.
! 807: dnl
! 808: dnl "C" and/or "dnl" are useful when an assembler doesn't support comments,
! 809: dnl or where different assemblers for a particular CPU have different
! 810: dnl comment styles. The intermediate ".s" files will end up with no
! 811: dnl comments, just code.
! 812: dnl
! 813: dnl Using "C" is not intended to cause offence to anyone who doesn't like
! 814: dnl FORTRAN; but if that happens it's an unexpected bonus.
! 815:
! 816: define(C, `
! 817: dnl')
! 818:
! 819:
! 820: dnl Various possible defines passed from the Makefile that are to be tested
! 821: dnl with ifdef() rather than be expanded.
! 822:
! 823: m4_not_for_expansion(`PIC')
! 824:
! 825: dnl aors_n
! 826: m4_not_for_expansion(`OPERATION_add_n')
! 827: m4_not_for_expansion(`OPERATION_sub_n')
! 828:
! 829: dnl aorsmul_n
! 830: m4_not_for_expansion(`OPERATION_addmul_1')
! 831: m4_not_for_expansion(`OPERATION_submul_1')
! 832:
! 833: dnl logops_n
! 834: m4_not_for_expansion(`OPERATION_and_n')
! 835: m4_not_for_expansion(`OPERATION_andn_n')
! 836: m4_not_for_expansion(`OPERATION_nand_n')
! 837: m4_not_for_expansion(`OPERATION_ior_n')
! 838: m4_not_for_expansion(`OPERATION_iorn_n')
! 839: m4_not_for_expansion(`OPERATION_nior_n')
! 840: m4_not_for_expansion(`OPERATION_xor_n')
! 841: m4_not_for_expansion(`OPERATION_xnor_n')
! 842:
! 843: dnl popham
! 844: m4_not_for_expansion(`OPERATION_popcount')
! 845: m4_not_for_expansion(`OPERATION_hamdist')
! 846:
! 847:
! 848: dnl Usage: m4_config_gmp_mparam(`symbol')
! 849: dnl
! 850: dnl Check that `symbol' is defined. If it isn't, issue an error and
! 851: dnl terminate immediately. The error message explains that the symbol
! 852: dnl should be in config.m4, copied from gmp-mparam.h.
! 853: dnl
! 854: dnl Processing is terminated immediately since missing something like
! 855: dnl KARATSUBA_SQR_THRESHOLD can lead to infinite loops with endless error
! 856: dnl messages.
! 857:
! 858: define(m4_config_gmp_mparam,
! 859: m4_assert_numargs(1)
! 860: `ifdef(`$1',,
! 861: `m4_error(`$1 is not defined.
! 862: "configure" should have extracted this from gmp-mparam.h and put it
! 863: in config.m4, but somehow this has failed.
! 864: ')m4exit(1)')')
! 865:
! 866:
! 867: dnl Usage: defreg(name,reg)
! 868: dnl
! 869: dnl Give a name to a $ style register. For example,
! 870: dnl
! 871: dnl defreg(foo,$12)
! 872: dnl
! 873: dnl defreg() inserts an extra pair of quotes after the $ so that it's not
! 874: dnl interpreted as an m4 macro parameter, ie. foo is actually $`'12. m4
! 875: dnl strips those quotes when foo is expanded.
! 876: dnl
! 877: dnl deflit() is used to make the new definition, so it will expand
! 878: dnl literally even if followed by parentheses ie. foo(99) will become
! 879: dnl $12(99). (But there's nowhere that would be used is there?)
! 880: dnl
! 881: dnl When making further definitions from existing defreg() macros, remember
! 882: dnl to use defreg() again to protect the $ in the new definitions too. For
! 883: dnl example,
! 884: dnl
! 885: dnl defreg(a0,$4)
! 886: dnl defreg(a1,$5)
! 887: dnl ...
! 888: dnl
! 889: dnl defreg(PARAM_DST,a0)
! 890: dnl
! 891: dnl This is only because a0 is expanding at the time the PARAM_DST
! 892: dnl definition is made, leaving a literal $4 that must be re-quoted. On
! 893: dnl the other hand in something like the following ra is only expanded when
! 894: dnl ret is used and its $`'31 protection will have its desired effect at
! 895: dnl that time.
! 896: dnl
! 897: dnl defreg(ra,$31)
! 898: dnl ...
! 899: dnl define(ret,`j ra')
! 900: dnl
! 901: dnl Note that only $n forms are meant to be used here, and something like
! 902: dnl 128($30) doesn't get protected and will come out wrong.
! 903:
! 904: define(defreg,
! 905: m4_assert_numargs(2)
! 906: `deflit(`$1',
! 907: substr(`$2',0,1)``''substr(`$2',1))')
! 908:
! 909:
! 910: dnl Usage: m4_instruction_wrapper(num)
! 911: dnl
! 912: dnl Put this, unquoted, on a line on its own, at the start of a macro
! 913: dnl that's a wrapper around an assembler instruction. It adds code to give
! 914: dnl a descriptive error message if the macro is invoked without arguments.
! 915: dnl
! 916: dnl For example, suppose jmp needs to be wrapped,
! 917: dnl
! 918: dnl define(jmp,
! 919: dnl m4_instruction_wrapper()
! 920: dnl m4_assert_numargs(1)
! 921: dnl `.byte 0x42
! 922: dnl .long $1
! 923: dnl nop')
! 924: dnl
! 925: dnl The point of m4_instruction_wrapper is to get a better error message
! 926: dnl than m4_assert_numargs would give if jmp is accidentally used as plain
! 927: dnl "jmp foo" instead of the intended "jmp( foo)". "jmp()" with no
! 928: dnl argument also provokes the error message.
! 929: dnl
! 930: dnl m4_instruction_wrapper should only be used with wrapped instructions
! 931: dnl that take arguments, since obviously something meant to be used as
! 932: dnl plain "ret", say, doesn't want to give an error when used that way.
! 933:
! 934: define(m4_instruction_wrapper,
! 935: m4_assert_numargs(0)
! 936: ``m4_instruction_wrapper_internal'(m4_doublequote($`'0),dnl
! 937: m4_doublequote(ifdef(`__file__',__file__,`the m4 sources')),dnl
! 938: $`#',m4_doublequote($`'1))`dnl'')
! 939:
! 940: dnl Called: m4_instruction_wrapper_internal($0,`filename',$#,$1)
! 941: define(m4_instruction_wrapper_internal,
! 942: `ifelse(eval($3<=1 && m4_length(`$4')==0),1,
! 943: `m4_error(`$1 is a macro replacing that instruction and needs arguments, see $2 for details
! 944: ')')')
! 945:
! 946:
! 947: dnl Usage: UNROLL_LOG2, UNROLL_MASK, UNROLL_BYTES
! 948: dnl CHUNK_LOG2, CHUNK_MASK, CHUNK_BYTES
! 949: dnl
! 950: dnl When code supports a variable amount of loop unrolling, the convention
! 951: dnl is to define UNROLL_COUNT to the number of limbs processed per loop.
! 952: dnl When testing code this can be varied to see how much the loop overhead
! 953: dnl is costing. For example,
! 954: dnl
! 955: dnl deflit(UNROLL_COUNT, 32)
! 956: dnl
! 957: dnl If the forloop() generating the unrolled loop has a pattern processing
! 958: dnl more than one limb, the convention is to express this with CHUNK_COUNT.
! 959: dnl For example,
! 960: dnl
! 961: dnl deflit(CHUNK_COUNT, 2)
! 962: dnl
! 963: dnl The LOG2, MASK and BYTES definitions below are derived from these COUNT
! 964: dnl definitions. If COUNT is redefined, the LOG2, MASK and BYTES follow
! 965: dnl the new definition automatically.
! 966: dnl
! 967: dnl LOG2 is the log base 2 of COUNT. MASK is COUNT-1, which can be used as
! 968: dnl a bit mask. BYTES is BYTES_PER_MP_LIMB*COUNT, the number of bytes
! 969: dnl processed in each unrolled loop.
! 970: dnl
! 971: dnl BYTES_PER_MP_LIMB is defined in a CPU specific m4 include file. It
! 972: dnl exists only so the BYTES definitions here can be common to all CPUs.
! 973: dnl In the actual code for a given CPU, an explicit 4 or 8 may as well be
! 974: dnl used because the code is only for a particular CPU, it doesn't need to
! 975: dnl be general.
! 976: dnl
! 977: dnl Note that none of these macros do anything except give conventional
! 978: dnl names to commonly used things. You still have to write your own
! 979: dnl expressions for a forloop() and the resulting address displacements.
! 980: dnl Something like the following would be typical for 4 bytes per limb.
! 981: dnl
! 982: dnl forloop(`i',0,UNROLL_COUNT-1,`
! 983: dnl deflit(`disp',eval(i*4))
! 984: dnl ...
! 985: dnl ')
! 986: dnl
! 987: dnl Or when using CHUNK_COUNT,
! 988: dnl
! 989: dnl forloop(`i',0,UNROLL_COUNT/CHUNK_COUNT-1,`
! 990: dnl deflit(`disp0',eval(i*CHUNK_COUNT*4))
! 991: dnl deflit(`disp1',eval(disp0+4))
! 992: dnl ...
! 993: dnl ')
! 994: dnl
! 995: dnl Clearly `i' can be run starting from 1, or from high to low or whatever
! 996: dnl best suits.
! 997:
! 998: deflit(UNROLL_LOG2,
! 999: m4_assert_defined(`UNROLL_COUNT')
! 1000: `m4_log2(UNROLL_COUNT)')
! 1001:
! 1002: deflit(UNROLL_MASK,
! 1003: m4_assert_defined(`UNROLL_COUNT')
! 1004: `eval(UNROLL_COUNT-1)')
! 1005:
! 1006: deflit(UNROLL_BYTES,
! 1007: m4_assert_defined(`UNROLL_COUNT')
! 1008: m4_assert_defined(`BYTES_PER_MP_LIMB')
! 1009: `eval(UNROLL_COUNT * BYTES_PER_MP_LIMB)')
! 1010:
! 1011: deflit(CHUNK_LOG2,
! 1012: m4_assert_defined(`CHUNK_COUNT')
! 1013: `m4_log2(CHUNK_COUNT)')
! 1014:
! 1015: deflit(CHUNK_MASK,
! 1016: m4_assert_defined(`CHUNK_COUNT')
! 1017: `eval(CHUNK_COUNT-1)')
! 1018:
! 1019: deflit(CHUNK_BYTES,
! 1020: m4_assert_defined(`CHUNK_COUNT')
! 1021: m4_assert_defined(`BYTES_PER_MP_LIMB')
! 1022: `eval(CHUNK_COUNT * BYTES_PER_MP_LIMB)')
! 1023:
! 1024:
! 1025: dnl Usage: MPN(name)
! 1026: dnl
! 1027: dnl Add MPN_PREFIX to a name.
! 1028: dnl MPN_PREFIX defaults to "__gmpn_" if not defined.
! 1029:
! 1030: ifdef(`MPN_PREFIX',,
! 1031: `define(`MPN_PREFIX',`__gmpn_')')
! 1032:
! 1033: define(MPN,
! 1034: m4_assert_numargs(1)
! 1035: `MPN_PREFIX`'$1')
! 1036:
! 1037:
! 1038: dnl Usage: mpn_add_n, etc
! 1039: dnl
! 1040: dnl Convenience definitions using MPN(), like the #defines in gmp.h. Each
! 1041: dnl function that might be implemented in assembler is here.
! 1042:
! 1043: define(define_mpn,
! 1044: m4_assert_numargs(1)
! 1045: `define(`mpn_$1',`MPN(`$1')')')
! 1046:
! 1047: define_mpn(add)
! 1048: define_mpn(add_1)
! 1049: define_mpn(add_n)
! 1050: define_mpn(add_nc)
! 1051: define_mpn(addmul_1)
! 1052: define_mpn(addmul_1c)
! 1053: define_mpn(addsub_n)
! 1054: define_mpn(addsub_nc)
! 1055: define_mpn(and_n)
! 1056: define_mpn(andn_n)
! 1057: define_mpn(bdivmod)
! 1058: define_mpn(cmp)
! 1059: define_mpn(com_n)
! 1060: define_mpn(copyd)
! 1061: define_mpn(copyi)
! 1062: define_mpn(divexact_by3c)
! 1063: define_mpn(divrem)
! 1064: define_mpn(divrem_1)
! 1065: define_mpn(divrem_1c)
! 1066: define_mpn(divrem_2)
! 1067: define_mpn(divrem_classic)
! 1068: define_mpn(divrem_newton)
! 1069: define_mpn(dump)
! 1070: define_mpn(gcd)
! 1071: define_mpn(gcd_1)
! 1072: define_mpn(gcdext)
! 1073: define_mpn(get_str)
! 1074: define_mpn(hamdist)
! 1075: define_mpn(invert_limb)
! 1076: define_mpn(ior_n)
! 1077: define_mpn(iorn_n)
! 1078: define_mpn(kara_mul_n)
! 1079: define_mpn(kara_sqr_n)
! 1080: define_mpn(lshift)
! 1081: define_mpn(lshiftc)
! 1082: define_mpn(mod_1)
! 1083: define_mpn(mod_1c)
! 1084: define_mpn(mul)
! 1085: define_mpn(mul_1)
! 1086: define_mpn(mul_1c)
! 1087: define_mpn(mul_basecase)
! 1088: define_mpn(mul_n)
! 1089: define_mpn(perfect_square_p)
! 1090: define_mpn(popcount)
! 1091: define_mpn(preinv_mod_1)
! 1092: define_mpn(nand_n)
! 1093: define_mpn(nior_n)
! 1094: define_mpn(random)
! 1095: define_mpn(random2)
! 1096: define_mpn(rshift)
! 1097: define_mpn(rshiftc)
! 1098: define_mpn(scan0)
! 1099: define_mpn(scan1)
! 1100: define_mpn(set_str)
! 1101: define_mpn(sqr_basecase)
! 1102: define_mpn(sub_n)
! 1103: define_mpn(sqrtrem)
! 1104: define_mpn(sub)
! 1105: define_mpn(sub_1)
! 1106: define_mpn(sub_n)
! 1107: define_mpn(sub_nc)
! 1108: define_mpn(submul_1)
! 1109: define_mpn(submul_1c)
! 1110: define_mpn(toom3_mul_n)
! 1111: define_mpn(toom3_sqr_n)
! 1112: define_mpn(umul_ppmm)
! 1113: define_mpn(udiv_qrnnd)
! 1114: define_mpn(xnor_n)
! 1115: define_mpn(xor_n)
! 1116:
! 1117: define(`ASM_START',
! 1118: `')
! 1119:
! 1120: define(`PROLOGUE',
! 1121: `
! 1122: TEXT
! 1123: ALIGN(4)
! 1124: GLOBL GSYM_PREFIX`$1'
! 1125: TYPE(GSYM_PREFIX`$1',`function')
! 1126: GSYM_PREFIX`$1':')
! 1127:
! 1128: define(`EPILOGUE',
! 1129: `
! 1130: SIZE(GSYM_PREFIX`$1',.-GSYM_PREFIX`$1')')
! 1131:
! 1132: dnl LSYM_PREFIX might be L$, so defn() must be used to quote it or the L
! 1133: dnl will expand as the L macro, an infinite recursion.
! 1134: define(`L',`defn(`LSYM_PREFIX')$1')
! 1135:
! 1136: define(`INT32',
! 1137: `
! 1138: ALIGN(4)
! 1139: $1:
! 1140: W32 $2
! 1141: ')
! 1142:
! 1143: define(`INT64',
! 1144: `
! 1145: ALIGN(8)
! 1146: $1:
! 1147: W32 $2
! 1148: W32 $3
! 1149: ')
! 1150:
! 1151:
! 1152: dnl Usage: ALIGN(bytes)
! 1153: dnl
! 1154: dnl Emit a ".align" directive. The alignment is specified in bytes, and
! 1155: dnl will normally need to be a power of 2. The actual ".align" generated
! 1156: dnl is either bytes or logarithmic according to what ./configure detects.
! 1157: dnl
! 1158: dnl ALIGN_FILL_0x90, if defined and equal to "yes", means a ", 0x90" should
! 1159: dnl be appended (this is for x86).
! 1160:
! 1161: define(ALIGN,
! 1162: m4_assert_numargs(1)
! 1163: m4_assert_defined(`ALIGN_LOGARITHMIC')
! 1164: `.align ifelse(ALIGN_LOGARITHMIC,yes,`m4_log2($1)',`eval($1)')dnl
! 1165: ifelse(ALIGN_FILL_0x90,yes,`, 0x90')')
! 1166:
! 1167:
! 1168: dnl Usage: MULFUNC_PROLOGUE(function function...)
! 1169: dnl
! 1170: dnl A dummy macro which is grepped for by ./configure to know what
! 1171: dnl functions a multi-function file is providing. Use this if there aren't
! 1172: dnl explicit PROLOGUE()s for each possible function.
! 1173: dnl
! 1174: dnl Multiple MULFUNC_PROLOGUEs can be used, or just one with the function
! 1175: dnl names separated by spaces.
! 1176:
! 1177: define(`MULFUNC_PROLOGUE',
! 1178: m4_assert_numargs(1)
! 1179: `')
! 1180:
! 1181:
! 1182: divert`'dnl
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to asm-defs.m4 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / mpn