From 11da511c784eca003deb90c23570f0873954e0de Mon Sep 17 00:00:00 2001 From: Duncan Wilkie Date: Sat, 18 Nov 2023 06:11:09 -0600 Subject: Initial commit. --- gmp-6.3.0/mpn/asm-defs.m4 | 1766 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1766 insertions(+) create mode 100644 gmp-6.3.0/mpn/asm-defs.m4 (limited to 'gmp-6.3.0/mpn/asm-defs.m4') diff --git a/gmp-6.3.0/mpn/asm-defs.m4 b/gmp-6.3.0/mpn/asm-defs.m4 new file mode 100644 index 0000000..1f2d9fe --- /dev/null +++ b/gmp-6.3.0/mpn/asm-defs.m4 @@ -0,0 +1,1766 @@ +divert(-1) +dnl +dnl m4 macros for gmp assembly code, shared by all CPUs. + +dnl Copyright 1999-2006, 2011 Free Software Foundation, Inc. + +dnl This file is part of the GNU MP Library. +dnl +dnl The GNU MP Library is free software; you can redistribute it and/or modify +dnl it under the terms of either: +dnl +dnl * the GNU Lesser General Public License as published by the Free +dnl Software Foundation; either version 3 of the License, or (at your +dnl option) any later version. +dnl +dnl or +dnl +dnl * the GNU General Public License as published by the Free Software +dnl Foundation; either version 2 of the License, or (at your option) any +dnl later version. +dnl +dnl or both in parallel, as here. +dnl +dnl The GNU MP Library is distributed in the hope that it will be useful, but +dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +dnl for more details. +dnl +dnl You should have received copies of the GNU General Public License and the +dnl GNU Lesser General Public License along with the GNU MP Library. If not, +dnl see https://www.gnu.org/licenses/. + + +dnl These macros are designed for use with any m4 and have been used on +dnl GNU, FreeBSD, NetBSD, OpenBSD and SysV. +dnl +dnl GNU m4 and OpenBSD 2.7 m4 will give filenames and line numbers in error +dnl messages. +dnl +dnl +dnl Macros: +dnl +dnl Most new m4 specific macros have an "m4_" prefix to emphasise they're +dnl m4 expansions. But new defining things like deflit() and defreg() are +dnl named like the builtin define(), and forloop() is named following the +dnl GNU m4 example on which it's based. +dnl +dnl GNU m4 with the -P option uses "m4_" as a prefix for builtins, but that +dnl option isn't going to be used, so there's no conflict or confusion. +dnl +dnl +dnl Comments in output: +dnl +dnl The m4 comment delimiters are left at # and \n, the normal assembler +dnl commenting for most CPUs. m4 passes comment text through without +dnl expanding macros in it, which is generally a good thing since it stops +dnl unexpected expansions and possible resultant errors. +dnl +dnl But note that when a quoted string is being read, a # isn't special, so +dnl apostrophes in comments in quoted strings must be avoided or they'll be +dnl interpreted as a closing quote mark. But when the quoted text is +dnl re-read # will still act like a normal comment, suppressing macro +dnl expansion. +dnl +dnl For example, +dnl +dnl # apostrophes in comments that're outside quotes are ok +dnl # and using macro names like PROLOGUE is ok too +dnl ... +dnl ifdef(`PIC',` +dnl # but apostrophes aren't ok inside quotes +dnl # ^--wrong +dnl ... +dnl # though macro names like PROLOGUE are still ok +dnl ... +dnl ') +dnl +dnl If macro expansion in a comment is wanted, use `#' in the .asm (ie. a +dnl quoted hash symbol), which will turn into # in the .s but get +dnl expansions done on that line. This can make the .s more readable to +dnl humans, but it won't make a blind bit of difference to the assembler. +dnl +dnl All the above applies, mutatis mutandis, when changecom() is used to +dnl select @ ! ; or whatever other commenting. +dnl +dnl +dnl Variations in m4 affecting gmp: +dnl +dnl $# - When a macro is called as "foo" with no brackets, BSD m4 sets $# +dnl to 1, whereas GNU or SysV m4 set it to 0. In all cases though +dnl "foo()" sets $# to 1. This is worked around in various places. +dnl +dnl len() - When "len()" is given an empty argument, BSD m4 evaluates to +dnl nothing, whereas GNU, SysV, and the new OpenBSD, evaluate to 0. +dnl See m4_length() below which works around this. +dnl +dnl translit() - GNU m4 accepts character ranges like A-Z, and the new +dnl OpenBSD m4 does under option -g, but basic BSD and SysV don't. +dnl +dnl popdef() - in BSD and SysV m4 popdef() takes multiple arguments and +dnl pops each, but GNU m4 only takes one argument. +dnl +dnl push back - BSD m4 has some limits on the amount of text that can be +dnl pushed back. The limit is reasonably big and so long as macros +dnl don't gratuitously duplicate big arguments it isn't a problem. +dnl Normally an error message is given, but sometimes it just hangs. +dnl +dnl eval() &,|,^ - GNU and SysV m4 have bitwise operators &,|,^ available, +dnl but BSD m4 doesn't (contrary to what the man page suggests) and +dnl instead ^ is exponentiation. +dnl +dnl eval() ?: - The C ternary operator "?:" is available in BSD m4, but not +dnl in SysV or GNU m4 (as of GNU m4 1.4 and betas of 1.5). +dnl +dnl eval() -2^31 - BSD m4 has a bug where an eval() resulting in -2^31 +dnl (ie. -2147483648) gives "-(". Using -2147483648 within an +dnl expression is ok, it just can't be a final result. "-(" will of +dnl course upset parsing, with all sorts of strange effects. +dnl +dnl eval() <<,>> - SysV m4 doesn't support shift operators in eval() (on +dnl Solaris 7 /usr/xpg4/m4 has them but /usr/ccs/m4 doesn't). See +dnl m4_lshift() and m4_rshift() below for workarounds. +dnl +dnl ifdef() - OSF 4.0 m4 considers a macro defined to a zero value `0' or +dnl `00' etc as not defined. See m4_ifdef below for a workaround. +dnl +dnl m4wrap() sequence - in BSD m4, m4wrap() replaces any previous m4wrap() +dnl string, in SysV m4 it appends to it, and in GNU m4 it prepends. +dnl See m4wrap_prepend() below which brings uniformity to this. +dnl +dnl m4wrap() 0xFF - old versions of BSD m4 store EOF in a C "char" under an +dnl m4wrap() and on systems where char is unsigned by default a +dnl spurious 0xFF is output. This has been observed on recent Cray +dnl Unicos Alpha, Apple MacOS X, and HPUX 11 systems. An autoconf +dnl test is used to check for this, see the m4wrap handling below. It +dnl might work to end the m4wrap string with a dnl to consume the +dnl 0xFF, but that probably induces the offending m4's to read from an +dnl already closed "FILE *", which could be bad on a glibc style +dnl stdio. +dnl +dnl __file__,__line__ - GNU m4 and OpenBSD 2.7 m4 provide these, and +dnl they're used here to make error messages more informative. GNU m4 +dnl gives an unhelpful "NONE 0" in an m4wrap(), but that's worked +dnl around. +dnl +dnl __file__ quoting - OpenBSD m4, unlike GNU m4, doesn't quote the +dnl filename in __file__, so care should be taken that no macro has +dnl the same name as a file, or an unwanted expansion will occur when +dnl printing an error or warning. +dnl +dnl changecom() - BSD m4 changecom doesn't quite work like the man page +dnl suggests, in particular "changecom" or "changecom()" doesn't +dnl disable the comment feature, and multi-character comment sequences +dnl don't seem to work. If the default `#' and newline aren't +dnl suitable it's necessary to change it to something else, +dnl eg. changecom(;). +dnl +dnl OpenBSD 2.6 m4 - in this m4, eval() rejects decimal constants containing +dnl an 8 or 9, making it pretty much unusable. The bug is confined to +dnl version 2.6 (it's not in 2.5, and was fixed in 2.7). +dnl +dnl SunOS /usr/bin/m4 - this m4 lacks a number of desired features, +dnl including $# and $@, defn(), m4exit(), m4wrap(), pushdef(), +dnl popdef(). /usr/5bin/m4 is a SysV style m4 which should always be +dnl available, and "configure" will reject /usr/bin/m4 in favour of +dnl /usr/5bin/m4 (if necessary). +dnl +dnl The sparc code actually has modest m4 requirements currently and +dnl could manage with /usr/bin/m4, but there's no reason to put our +dnl macros through contortions when /usr/5bin/m4 is available or GNU +dnl m4 can be installed. + + +ifdef(`__ASM_DEFS_M4_INCLUDED__', +`m4_error(`asm-defs.m4 already included, dont include it twice +')m4exit(1)') +define(`__ASM_DEFS_M4_INCLUDED__') + + +dnl Detect and give a message about the unsuitable OpenBSD 2.6 m4. + +ifelse(eval(89),89,, +`errprint( +`This m4 doesnt accept 8 and/or 9 in constants in eval(), making it unusable. +This is probably OpenBSD 2.6 m4 (September 1999). Upgrade to OpenBSD 2.7, +or get a bug fix from the CVS (expr.c rev 1.9), or get GNU m4. Dont forget +to configure with M4=/wherever/m4 if you install one of these in a directory +not in $PATH. +')m4exit(1)') + + +dnl Detect and give a message about the unsuitable SunOS /usr/bin/m4. +dnl +dnl Unfortunately this test doesn't work when m4 is run in the normal way +dnl from mpn/Makefile with "m4 -DOPERATION_foo foo.asm", since the bad m4 +dnl takes "-" in "-D..." to mean read stdin, so it will look like it just +dnl hangs. But running "m4 asm-defs.m4" to try it out will work. +dnl +dnl We'd like to abort immediately on finding a problem, but unfortunately +dnl the bad m4 doesn't have an m4exit(), nor does an invalid eval() kill +dnl it. Unexpanded $#'s in some m4_assert_numargs() later on will comment +dnl out some closing parentheses and kill it with "m4: arg stack overflow". + +define(m4_dollarhash_works_test,``$#'') +ifelse(m4_dollarhash_works_test(x),1,, +`errprint( +`This m4 doesnt support $# and cant be used for GMP asm processing. +If this is on SunOS, ./configure should choose /usr/5bin/m4 if you have that +or can get it, otherwise install GNU m4. Dont forget to configure with +M4=/wherever/m4 if you install in a directory not in $PATH. +')') +undefine(`m4_dollarhash_works_test') + + +dnl -------------------------------------------------------------------------- +dnl Basic error handling things. + + +dnl Usage: m4_dollarhash_1_if_noparen_p +dnl +dnl Expand to 1 if a call "foo" gives $# set to 1 (as opposed to 0 like GNU +dnl and SysV m4 give). + +define(m4_dollarhash_1_if_noparen_test,`$#') +define(m4_dollarhash_1_if_noparen_p, +eval(m4_dollarhash_1_if_noparen_test==1)) +undefine(`m4_dollarhash_1_if_noparen_test') + + +dnl Usage: m4wrap_prepend(string) +dnl +dnl Prepend the given string to what will be expanded under m4wrap at the +dnl end of input. +dnl +dnl This macro exists to work around variations in m4wrap() behaviour in +dnl the various m4s (notes at the start of this file). Don't use m4wrap() +dnl directly since it will interfere with this scheme. + +define(m4wrap_prepend, +m4_assert_numargs(1) +`define(`m4wrap_string',`$1'defn(`m4wrap_string'))') + +define(m4wrap_string,`') + +define(m4wrap_works_p, +`ifelse(M4WRAP_SPURIOUS,yes,0,1)') + +ifelse(m4wrap_works_p,1, +`m4wrap(`m4wrap_string')') + + +dnl Usage: m4_file_and_line +dnl +dnl Expand to the current file and line number, if the GNU m4 extensions +dnl __file__ and __line__ are available. +dnl +dnl In GNU m4 1.4 at the end of input when m4wrap text is expanded, +dnl __file__ is NONE and __line__ is 0, which is not a helpful thing to +dnl print. If m4_file_seen() has been called to note the last file seen, +dnl then that file at a big line number is used, otherwise "end of input" +dnl is used (although "end of input" won't parse as an error message). + +define(m4_file_and_line, +`ifdef(`__file__', +`ifelse(__file__`'__line__,`NONE0', +`ifdef(`m4_file_seen_last',`m4_file_seen_last: 999999: ',`end of input: ')', +`__file__: __line__: ')')') + + +dnl Usage: m4_errprint_commas(arg,...) +dnl +dnl The same as errprint(), but commas are printed between arguments +dnl instead of spaces. + +define(m4_errprint_commas, +`errprint(`$1')dnl +ifelse(eval($#>1),1,`errprint(`,')m4_errprint_commas(shift($@))')') + + +dnl Usage: m4_error(args...) +dnl m4_warning(args...) +dnl +dnl Print an error message, using m4_errprint_commas, prefixed with the +dnl current filename and line number (if available). m4_error sets up to +dnl give an error exit at the end of processing, m4_warning just prints. +dnl These macros are the recommended way to print errors. +dnl +dnl The arguments here should be quoted in the usual way to prevent them +dnl being expanded when the macro call is read. (m4_error takes care not +dnl to do any further expansion.) +dnl +dnl For example, +dnl +dnl m4_error(`some error message +dnl ') +dnl +dnl which prints +dnl +dnl foo.asm:123: some error message +dnl +dnl or if __file__ and __line__ aren't available +dnl +dnl some error message +dnl +dnl The "file:line:" format is a basic style, used by gcc and GNU m4, so +dnl emacs and other editors will recognise it in their normal error message +dnl parsing. + +define(m4_warning, +`m4_errprint_commas(m4_file_and_line`'$@)') + +define(m4_error, +`define(`m4_error_occurred',1)m4_warning($@)dnl +ifelse(m4wrap_works_p,0,`m4exit(1)')') + +define(`m4_error_occurred',0) + +dnl This m4wrap_prepend() is first, so it'll be executed last. +m4wrap_prepend( +`ifelse(m4_error_occurred,1, +`m4_error(`Errors occurred during m4 processing +')m4exit(1)')') + + +dnl Usage: m4_assert_numargs(num) +dnl +dnl Put this unquoted on a line on its own at the start of a macro +dnl definition to add some code to check that num many arguments get passed +dnl to the macro. For example, +dnl +dnl define(foo, +dnl m4_assert_numargs(2) +dnl `something `$1' and `$2' blah blah') +dnl +dnl Then a call like foo(one,two,three) will provoke an error like +dnl +dnl file:10: foo expected 2 arguments, got 3 arguments +dnl +dnl Here are some calls and how many arguments they're interpreted as passing. +dnl +dnl foo(abc,def) 2 +dnl foo(xyz) 1 +dnl foo() 0 +dnl foo -1 +dnl +dnl The -1 for no parentheses at all means a macro that's meant to be used +dnl that way can be checked with m4_assert_numargs(-1). For example, +dnl +dnl define(SPECIAL_SUFFIX, +dnl m4_assert_numargs(-1) +dnl `ifdef(`FOO',`_foo',`_bar')') +dnl +dnl But as an alternative see also deflit() below where parenthesized +dnl expressions following a macro are passed through to the output. +dnl +dnl Note that in BSD m4 there's no way to differentiate calls "foo" and +dnl "foo()", so in BSD m4 the distinction between the two isn't enforced. +dnl (In GNU and SysV m4 it can be checked, and is.) + + +dnl m4_assert_numargs is able to check its own arguments by calling +dnl assert_numargs_internal directly. +dnl +dnl m4_doublequote($`'0) expands to ``$0'', whereas ``$`'0'' would expand +dnl to `$`'0' and do the wrong thing, and likewise for $1. The same is +dnl done in other assert macros. +dnl +dnl $`#' leaves $# in the new macro being defined, and stops # being +dnl interpreted as a comment character. +dnl +dnl `dnl ' means an explicit dnl isn't necessary when m4_assert_numargs is +dnl used. The space means that if there is a dnl it'll still work. + +dnl Usage: m4_doublequote(x) expands to ``x'' +define(m4_doublequote, +`m4_assert_numargs_internal(`$0',1,$#,len(`$1'))``$1''') + +define(m4_assert_numargs, +`m4_assert_numargs_internal(`$0',1,$#,len(`$1'))dnl +`m4_assert_numargs_internal'(m4_doublequote($`'0),$1,$`#',`len'(m4_doublequote($`'1)))`dnl '') + +dnl Called: m4_assert_numargs_internal(`macroname',wantargs,$#,len(`$1')) +define(m4_assert_numargs_internal, +`m4_assert_numargs_internal_check(`$1',`$2',m4_numargs_count(`$3',`$4'))') + +dnl Called: m4_assert_numargs_internal_check(`macroname',wantargs,gotargs) +dnl +dnl If m4_dollarhash_1_if_noparen_p (BSD m4) then gotargs can be 0 when it +dnl should be -1. If wantargs is -1 but gotargs is 0 and the two can't be +dnl distinguished then it's allowed to pass. +dnl +define(m4_assert_numargs_internal_check, +`ifelse(eval($2 == $3 + || ($2==-1 && $3==0 && m4_dollarhash_1_if_noparen_p)),0, +`m4_error(`$1 expected 'm4_Narguments(`$2')`, got 'm4_Narguments(`$3') +)')') + +dnl Called: m4_numargs_count($#,len(`$1')) +dnl If $#==0 then -1 args, if $#==1 but len(`$1')==0 then 0 args, otherwise +dnl $# args. +define(m4_numargs_count, +`ifelse($1,0, -1, +`ifelse(eval($1==1 && $2-0==0),1, 0, $1)')') + +dnl Usage: m4_Narguments(N) +dnl "$1 argument" or "$1 arguments" with the plural according to $1. +define(m4_Narguments, +`$1 argument`'ifelse(`$1',1,,s)') + + +dnl -------------------------------------------------------------------------- +dnl Additional error checking things. + + +dnl Usage: m4_file_seen() +dnl +dnl Record __file__ for the benefit of m4_file_and_line in m4wrap text. +dnl +dnl The basic __file__ macro comes out quoted in GNU m4, like `foo.asm', +dnl and m4_file_seen_last is defined like that too. +dnl +dnl This is used by PROLOGUE, since that's normally in the main .asm file, +dnl and in particular it sets up m4wrap error checks for missing EPILOGUE. + +define(m4_file_seen, +m4_assert_numargs(0) +`ifelse(__file__,`NONE',, +`define(`m4_file_seen_last',m4_doublequote(__file__))')') + + +dnl Usage: m4_assert_onearg() +dnl +dnl Put this, unquoted, at the start of a macro definition to add some code +dnl to check that one argument is passed to the macro, but with that +dnl argument allowed to be empty. For example, +dnl +dnl define(foo, +dnl m4_assert_onearg() +dnl `blah blah $1 blah blah') +dnl +dnl Calls "foo(xyz)" or "foo()" are accepted. A call "foo(xyz,abc)" fails. +dnl A call "foo" fails too, but BSD m4 can't detect this case (GNU and SysV +dnl m4 can). + +define(m4_assert_onearg, +m4_assert_numargs(0) +`m4_assert_onearg_internal'(m4_doublequote($`'0),$`#')`dnl ') + +dnl Called: m4_assert_onearg(`macroname',$#) +define(m4_assert_onearg_internal, +`ifelse($2,1,, +`m4_error(`$1 expected 1 argument, got 'm4_Narguments(`$2') +)')') + + +dnl Usage: m4_assert_numargs_range(low,high) +dnl +dnl Put this, unquoted, at the start of a macro definition to add some code +dnl to check that between low and high many arguments get passed to the +dnl macro. For example, +dnl +dnl define(foo, +dnl m4_assert_numargs_range(3,5) +dnl `mandatory $1 $2 $3 optional $4 $5 end') +dnl +dnl See m4_assert_numargs() for more info. + +define(m4_assert_numargs_range, +m4_assert_numargs(2) +``m4_assert_numargs_range_internal'(m4_doublequote($`'0),$1,$2,$`#',`len'(m4_doublequote($`'1)))`dnl '') + +dnl Called: m4_assert_numargs_range_internal(`name',low,high,$#,len(`$1')) +define(m4_assert_numargs_range_internal, +m4_assert_numargs(5) +`m4_assert_numargs_range_check(`$1',`$2',`$3',m4_numargs_count(`$4',`$5'))') + +dnl Called: m4_assert_numargs_range_check(`name',low,high,gotargs) +dnl +dnl If m4_dollarhash_1_if_noparen_p (BSD m4) then gotargs can be 0 when it +dnl should be -1. To ensure a `high' of -1 works, a fudge is applied to +dnl gotargs if it's 0 and the 0 and -1 cases can't be distinguished. +dnl +define(m4_assert_numargs_range_check, +m4_assert_numargs(4) +`ifelse(eval($2 <= $4 && + ($4 - ($4==0 && m4_dollarhash_1_if_noparen_p) <= $3)),0, +`m4_error(`$1 expected $2 to $3 arguments, got 'm4_Narguments(`$4') +)')') + + +dnl Usage: m4_assert_defined(symbol) +dnl +dnl Put this unquoted on a line of its own at the start of a macro +dnl definition to add some code to check that the given symbol is defined +dnl when the macro is used. For example, +dnl +dnl define(foo, +dnl m4_assert_defined(`FOO_PREFIX') +dnl `FOO_PREFIX whatever') +dnl +dnl This is a convenient way to check that the user or ./configure or +dnl whatever has defined the things needed by a macro, as opposed to +dnl silently generating garbage. + +define(m4_assert_defined, +m4_assert_numargs(1) +``m4_assert_defined_internal'(m4_doublequote($`'0),``$1'')`dnl '') + +dnl Called: m4_assert_defined_internal(`macroname',`define_required') +define(m4_assert_defined_internal, +m4_assert_numargs(2) +`m4_ifdef(`$2',, +`m4_error(`$1 needs $2 defined +')')') + + +dnl Usage: m4_not_for_expansion(`SYMBOL') +dnl define_not_for_expansion(`SYMBOL') +dnl +dnl m4_not_for_expansion turns SYMBOL, if defined, into something which +dnl will give an error if expanded. For example, +dnl +dnl m4_not_for_expansion(`PIC') +dnl +dnl define_not_for_expansion is the same, but always makes a definition. +dnl +dnl These are for symbols that should be tested with ifdef(`FOO',...) +dnl rather than be expanded as such. They guard against accidentally +dnl omitting the quotes, as in ifdef(FOO,...). Note though that they only +dnl catches this when FOO is defined, so be sure to test code both with and +dnl without each definition. + +define(m4_not_for_expansion, +m4_assert_numargs(1) +`ifdef(`$1',`define_not_for_expansion(`$1')')') + +define(define_not_for_expansion, +m4_assert_numargs(1) +`ifelse(defn(`$1'),,, +`m4_error(``$1' has a non-empty value, maybe it shouldnt be munged with m4_not_for_expansion() +')')dnl +define(`$1',`m4_not_for_expansion_internal(`$1')')') + +define(m4_not_for_expansion_internal, +`m4_error(``$1' is not meant to be expanded, perhaps you mean `ifdef(`$1',...)' +')') + + +dnl -------------------------------------------------------------------------- +dnl Various generic m4 things. + + +dnl Usage: m4_unquote(macro) +dnl +dnl Allow the argument text to be re-evaluated. This is useful for "token +dnl pasting" like m4_unquote(foo`'bar). + +define(m4_unquote, +m4_assert_onearg() +`$1') + + +dnl Usage: m4_ifdef(name,yes[,no]) +dnl +dnl Expand to the yes argument if name is defined, or to the no argument if +dnl not. +dnl +dnl This is the same as the builtin "ifdef", but avoids an OSF 4.0 m4 bug +dnl in which a macro with a zero value `0' or `00' etc is considered not +dnl defined. +dnl +dnl There's no particular need to use this everywhere, only if there might +dnl be a zero value. + +define(m4_ifdef, +m4_assert_numargs_range(2,3) +`ifelse(eval(ifdef(`$1',1,0)+m4_length(defn(`$1'))),0, +`$3',`$2')') + + +dnl Usage: m4_ifdef_anyof_p(`symbol',...) +dnl +dnl Expand to 1 if any of the symbols in the argument list are defined, or +dnl to 0 if not. + +define(m4_ifdef_anyof_p, +`ifelse(eval($#<=1 && m4_length(`$1')==0),1, 0, +`ifdef(`$1', 1, +`m4_ifdef_anyof_p(shift($@))')')') + + +dnl Usage: m4_length(string) +dnl +dnl Determine the length of a string. This is the same as len(), but +dnl always expands to a number, working around the BSD len() which +dnl evaluates to nothing given an empty argument. + +define(m4_length, +m4_assert_onearg() +`eval(len(`$1')-0)') + + +dnl Usage: m4_stringequal_p(x,y) +dnl +dnl Expand to 1 or 0 according as strings x and y are equal or not. + +define(m4_stringequal_p, +`ifelse(`$1',`$2',1,0)') + + +dnl Usage: m4_incr_or_decr(n,last) +dnl +dnl Do an incr(n) or decr(n), whichever is in the direction of "last". +dnl Both n and last must be numbers of course. + +define(m4_incr_or_decr, +m4_assert_numargs(2) +`ifelse(eval($1<$2),1,incr($1),decr($1))') + + +dnl Usage: forloop(i, first, last, statement) +dnl +dnl Based on GNU m4 examples/forloop.m4, but extended. +dnl +dnl statement is expanded repeatedly, with i successively defined as +dnl +dnl first, first+1, ..., last-1, last +dnl +dnl Or if first > last, then it's +dnl +dnl first, first-1, ..., last+1, last +dnl +dnl If first == last, then one expansion is done. +dnl +dnl A pushdef/popdef of i is done to preserve any previous definition (or +dnl lack of definition). first and last are eval()ed and so can be +dnl expressions. +dnl +dnl forloop_first is defined to 1 on the first iteration, 0 on the rest. +dnl forloop_last is defined to 1 on the last iteration, 0 on the others. +dnl Nested forloops are allowed, in which case forloop_first and +dnl forloop_last apply to the innermost loop that's open. +dnl +dnl A simple example, +dnl +dnl forloop(i, 1, 2*2+1, `dnl +dnl iteration number i ... ifelse(forloop_first,1,FIRST) +dnl ') + + +dnl "i" and "statement" are carefully quoted, but "first" and "last" are +dnl just plain numbers once eval()ed. + +define(`forloop', +m4_assert_numargs(4) +`pushdef(`$1',eval(`$2'))dnl +pushdef(`forloop_first',1)dnl +pushdef(`forloop_last',0)dnl +forloop_internal(`$1',eval(`$3'),`$4')`'dnl +popdef(`forloop_first')dnl +popdef(`forloop_last')dnl +popdef(`$1')') + +dnl Called: forloop_internal(`var',last,statement) +define(`forloop_internal', +m4_assert_numargs(3) +`ifelse($1,$2, +`define(`forloop_last',1)$3', +`$3`'dnl +define(`forloop_first',0)dnl +define(`$1',m4_incr_or_decr($1,$2))dnl +forloop_internal(`$1',$2,`$3')')') + + +dnl Usage: foreach(var,body, item1,item2,...,itemN) +dnl +dnl For each "item" argument, define "var" to that value and expand "body". +dnl For example, +dnl +dnl foreach(i, `something i +dnl ', one, two) +dnl gives +dnl something one +dnl something two +dnl +dnl Any previous definition of "var", or lack thereof, is saved and +dnl restored. Empty "item"s are not allowed. + +define(foreach, +m4_assert_numargs_range(2,1000) +`ifelse(`$3',,, +`pushdef(`$1',`$3')$2`'popdef(`$1')dnl +foreach(`$1',`$2',shift(shift(shift($@))))')') + + +dnl Usage: m4_toupper(x) +dnl m4_tolower(x) +dnl +dnl Convert the argument string to upper or lower case, respectively. +dnl Only one argument accepted. +dnl +dnl BSD m4 doesn't take ranges like a-z in translit(), so the full alphabet +dnl is written out. + +define(m4_alphabet_lower, `abcdefghijklmnopqrstuvwxyz') +define(m4_alphabet_upper, `ABCDEFGHIJKLMNOPQRSTUVWXYZ') + +define(m4_toupper, +m4_assert_onearg() +`translit(`$1', m4_alphabet_lower, m4_alphabet_upper)') + +define(m4_tolower, +m4_assert_onearg() +`translit(`$1', m4_alphabet_upper, m4_alphabet_lower)') + + +dnl Usage: m4_empty_if_zero(x) +dnl +dnl Evaluate to x, or to nothing if x is 0. x is eval()ed and so can be an +dnl expression. +dnl +dnl This is useful for x86 addressing mode displacements since forms like +dnl (%ebx) are one byte shorter than 0(%ebx). A macro `foo' for use as +dnl foo(%ebx) could be defined with the following so it'll be empty if the +dnl expression comes out zero. +dnl +dnl deflit(`foo', `m4_empty_if_zero(a+b*4-c)') +dnl +dnl Naturally this shouldn't be done if, say, a computed jump depends on +dnl the code being a particular size. + +define(m4_empty_if_zero, +m4_assert_onearg() +`ifelse(eval($1),0,,eval($1))') + + +dnl Usage: m4_log2(x) +dnl +dnl Calculate a logarithm to base 2. +dnl x must be an integral power of 2, between 2**0 and 2**30. +dnl x is eval()ed, so it can be an expression. +dnl An error results if x is invalid. +dnl +dnl 2**31 isn't supported, because an unsigned 2147483648 is out of range +dnl of a 32-bit signed int. Also, the bug in BSD m4 where an eval() +dnl resulting in 2147483648 (or -2147483648 as the case may be) gives `-(' +dnl means tests like eval(1<<31==(x)) would be necessary, but that then +dnl gives an unattractive explosion of eval() error messages if x isn't +dnl numeric. + +define(m4_log2, +m4_assert_numargs(1) +`m4_log2_internal(0,1,eval(`$1'))') + +dnl Called: m4_log2_internal(n,2**n,target) +define(m4_log2_internal, +m4_assert_numargs(3) +`ifelse($2,$3,$1, +`ifelse($1,30, +`m4_error(`m4_log2() argument too big or not a power of two: $3 +')', +`m4_log2_internal(incr($1),eval(2*$2),$3)')')') + + +dnl Usage: m4_div2_towards_zero +dnl +dnl m4 division is probably whatever a C signed division is, and C doesn't +dnl specify what rounding gets used on negatives, so this expression forces +dnl a rounding towards zero. + +define(m4_div2_towards_zero, +m4_assert_numargs(1) +`eval((($1) + ((($1)<0) & ($1))) / 2)') + + +dnl Usage: m4_lshift(n,count) +dnl m4_rshift(n,count) +dnl +dnl Calculate n shifted left or right by count many bits. Both n and count +dnl are eval()ed and so can be expressions. +dnl +dnl Negative counts are allowed and mean a shift in the opposite direction. +dnl Negative n is allowed and right shifts will be arithmetic (meaning +dnl divide by 2**count, rounding towards zero, also meaning the sign bit is +dnl duplicated). +dnl +dnl Use these macros instead of << and >> in eval() since the basic ccs +dnl SysV m4 doesn't have those operators. + +define(m4_rshift, +m4_assert_numargs(2) +`m4_lshift(`$1',-(`$2'))') + +define(m4_lshift, +m4_assert_numargs(2) +`m4_lshift_internal(eval(`$1'),eval(`$2'))') + +define(m4_lshift_internal, +m4_assert_numargs(2) +`ifelse(eval($2-0==0),1,$1, +`ifelse(eval($2>0),1, +`m4_lshift_internal(eval($1*2),decr($2))', +`m4_lshift_internal(m4_div2_towards_zero($1),incr($2))')')') + + +dnl Usage: m4_popcount(n) +dnl +dnl Expand to the number 1 bits in n. + +define(m4_popcount, +m4_assert_numargs(1) +`m4_popcount_internal(0,eval(`$1'))') + +dnl Called: m4_popcount_internal(count,rem) +define(m4_popcount_internal, +m4_assert_numargs(2) +`ifelse($2,0,$1, +`m4_popcount_internal(eval($1+($2%2)),eval($2/2))')') + + +dnl Usage: m4_count_trailing_zeros(N) +dnl +dnl Determine the number of trailing zero bits on N. N is eval()ed and so +dnl can be an expression. If N is zero an error is generated. + +define(m4_count_trailing_zeros, +m4_assert_numargs(1) +`m4_count_trailing_zeros_internal(eval(`$1'),0)') + +dnl Called: m4_count_trailing_zeros_internal(val,count) +define(m4_count_trailing_zeros_internal, +m4_assert_numargs(2) +`ifelse($1,0, +`m4_error(`m4_count_trailing_zeros() given a zero value')', +`ifelse(eval(($1)%2),1,`$2', +`m4_count_trailing_zeros_internal(eval($1/2),incr($2))')')') + + +dnl Usage: deflit(name,value) +dnl +dnl Like define(), but "name" expands like a literal, rather than taking +dnl arguments. For example "name(%eax)" expands to "value(%eax)". +dnl +dnl Limitations: +dnl +dnl $ characters in the value part must have quotes to stop them looking +dnl like macro parameters. For example, deflit(reg,`123+$`'4+567'). See +dnl defreg() below for handling simple register definitions like $7 etc. +dnl +dnl "name()" is turned into "name", unfortunately. In GNU and SysV m4 an +dnl error is generated when this happens, but in BSD m4 it will happen +dnl silently. The problem is that in BSD m4 $# is 1 in both "name" or +dnl "name()", so there's no way to differentiate them. Because we want +dnl plain "name" to turn into plain "value", we end up with "name()" +dnl turning into plain "value" too. +dnl +dnl "name(foo)" will lose any whitespace after commas in "foo", for example +dnl "disp(%eax, %ecx)" would become "128(%eax,%ecx)". +dnl +dnl These parentheses oddities shouldn't matter in assembler text, but if +dnl they do the suggested workaround is to write "name ()" or "name (foo)" +dnl to stop the parentheses looking like a macro argument list. If a space +dnl isn't acceptable in the output, then write "name`'()" or "name`'(foo)". +dnl The `' is stripped when read, but again stops the parentheses looking +dnl like parameters. + +dnl Quoting for deflit_emptyargcheck is similar to m4_assert_numargs. The +dnl stuff in the ifelse gives a $#, $1 and $@ evaluated in the new macro +dnl created, not in deflit. +define(deflit, +m4_assert_numargs(2) +`define(`$1', +`deflit_emptyargcheck'(``$1'',$`#',m4_doublequote($`'1))`dnl +$2`'dnl +ifelse(eval($'`#>1 || m4_length('m4_doublequote($`'1)`)!=0),1,($'`@))')') + +dnl Called: deflit_emptyargcheck(macroname,$#,`$1') +define(deflit_emptyargcheck, +`ifelse(eval($2==1 && !m4_dollarhash_1_if_noparen_p && m4_length(`$3')==0),1, +`m4_error(`dont use a deflit as $1() because it loses the brackets (see deflit in asm-defs.m4 for more information) +')')') + + +dnl Usage: m4_assert(`expr') +dnl +dnl Test a compile-time requirement with an m4 expression. The expression +dnl should be quoted, and will be eval()ed and expected to be non-zero. +dnl For example, +dnl +dnl m4_assert(`FOO*2+6 < 14') + +define(m4_assert, +m4_assert_numargs(1) +`ifelse(eval($1),1,, +`m4_error(`assertion failed: $1 +')')') + + +dnl Usage: m4_repeat(count,text) +dnl +dnl Expand to the given repetitions of the given text. A zero count is +dnl allowed, and expands to nothing. + +define(m4_repeat, +m4_assert_numargs(2) +`m4_repeat_internal(eval($1),`$2')') + +define(m4_repeat_internal, +m4_assert_numargs(2) +`ifelse(`$1',0,, +`forloop(m4_repeat_internal_counter,1,$1,``$2'')')') + + +dnl Usage: m4_hex_lowmask(bits) +dnl +dnl Generate a hex constant which is a low mask of the given number of +dnl bits. For example m4_hex_lowmask(10) would give 0x3ff. + +define(m4_hex_lowmask, +m4_assert_numargs(1) +`m4_cpu_hex_constant(m4_hex_lowmask_internal1(eval(`$1')))') + +dnl Called: m4_hex_lowmask_internal1(bits) +define(m4_hex_lowmask_internal1, +m4_assert_numargs(1) +`ifelse($1,0,`0', +`m4_hex_lowmask_internal2(eval(($1)%4),eval(($1)/4))')') + +dnl Called: m4_hex_lowmask_internal(remainder,digits) +define(m4_hex_lowmask_internal2, +m4_assert_numargs(2) +`ifelse($1,1,`1', +`ifelse($1,2,`3', +`ifelse($1,3,`7')')')dnl +m4_repeat($2,`f')') + + +dnl -------------------------------------------------------------------------- +dnl The following m4_list functions take a list as multiple arguments. +dnl Arguments are evaluated multiple times, there's no attempt at strict +dnl quoting. Empty list elements are not allowed, since an empty final +dnl argument is ignored. These restrictions don't affect the current uses, +dnl and make the implementation easier. + + +dnl Usage: m4_list_quote(list,...) +dnl +dnl Produce a list with quoted commas, so it can be a single argument +dnl string. For instance m4_list_quote(a,b,c) gives +dnl +dnl a`,'b`,'c`,' +dnl +dnl This can be used to put a list in a define, +dnl +dnl define(foolist, m4_list_quote(a,b,c)) +dnl +dnl Which can then be used for instance as +dnl +dnl m4_list_find(target, foolist) + +define(m4_list_quote, +`ifelse(`$1',,, +`$1`,'m4_list_quote(shift($@))')') + + +dnl Usage: m4_list_find(key,list,...) +dnl +dnl Evaluate to 1 or 0 according to whether key is in the list elements. + +define(m4_list_find, +m4_assert_numargs_range(1,1000) +`ifelse(`$2',,0, +`ifelse(`$1',`$2',1, +`m4_list_find(`$1',shift(shift($@)))')')') + + +dnl Usage: m4_list_remove(key,list,...) +dnl +dnl Evaluate to the given list with `key' removed (if present). + +define(m4_list_remove, +m4_assert_numargs_range(1,1000) +`ifelse(`$2',,, +`ifelse(`$1',`$2',,`$2,')dnl +m4_list_remove(`$1',shift(shift($@)))')') + + +dnl Usage: m4_list_first(list,...) +dnl +dnl Evaluate to the first element of the list (if any). + +define(m4_list_first,`$1') + + +dnl Usage: m4_list_count(list,...) +dnl +dnl Evaluate to the number of elements in the list. This can't just use $# +dnl because the last element might be empty. + +define(m4_list_count, +`m4_list_count_internal(0,$@)') + +dnl Called: m4_list_internal(count,list,...) +define(m4_list_count_internal, +m4_assert_numargs_range(1,1000) +`ifelse(`$2',,$1, +`m4_list_count_internal(eval($1+1),shift(shift($@)))')') + + +dnl -------------------------------------------------------------------------- +dnl Various assembler things, not specific to any particular CPU. +dnl + + +dnl Usage: include_mpn(`filename') +dnl +dnl Like include(), but adds a path to the mpn source directory. For +dnl example, +dnl +dnl include_mpn(`sparc64/addmul_1h.asm') + +define(include_mpn, +m4_assert_numargs(1) +m4_assert_defined(`CONFIG_TOP_SRCDIR') +`include(CONFIG_TOP_SRCDIR`/mpn/$1')') + + +dnl Usage: C comment ... +dnl +dnl This works like a FORTRAN-style comment character. It can be used for +dnl comments to the right of assembly instructions, where just dnl would +dnl remove the newline and concatenate adjacent lines. +dnl +dnl C and/or dnl are useful when an assembler doesn't support comments, or +dnl where different assemblers for a particular CPU need different styles. +dnl The intermediate ".s" files will end up with no comments, just code. +dnl +dnl Using C is not intended to cause offence to anyone who doesn't like +dnl FORTRAN; but if that happens it's an unexpected bonus. +dnl +dnl During development, if comments are wanted in the .s files to help see +dnl what's expanding where, C can be redefined with something like +dnl +dnl define(`C',`#') + +define(C, ` +dnl') + + +dnl Normally PIC is defined (or not) by libtool, but it doesn't set it on +dnl systems which are always PIC. PIC_ALWAYS established in config.m4 +dnl identifies these for us. + +ifelse(PIC_ALWAYS,`yes',`define(`PIC')') + + +dnl Various possible defines passed from the Makefile that are to be tested +dnl with ifdef() rather than be expanded. + +m4_not_for_expansion(`PIC') +m4_not_for_expansion(`DLL_EXPORT') + +dnl aors_n +m4_not_for_expansion(`OPERATION_add_n') +m4_not_for_expansion(`OPERATION_sub_n') + +dnl aors_err1_n +m4_not_for_expansion(`OPERATION_add_err1_n') +m4_not_for_expansion(`OPERATION_sub_err1_n') + +dnl aors_err2_n +m4_not_for_expansion(`OPERATION_add_err2_n') +m4_not_for_expansion(`OPERATION_sub_err2_n') + +dnl aors_err3_n +m4_not_for_expansion(`OPERATION_add_err3_n') +m4_not_for_expansion(`OPERATION_sub_err3_n') + +dnl aorsmul_1 +m4_not_for_expansion(`OPERATION_addmul_1') +m4_not_for_expansion(`OPERATION_submul_1') + +dnl logops_n +m4_not_for_expansion(`OPERATION_and_n') +m4_not_for_expansion(`OPERATION_andn_n') +m4_not_for_expansion(`OPERATION_nand_n') +m4_not_for_expansion(`OPERATION_ior_n') +m4_not_for_expansion(`OPERATION_iorn_n') +m4_not_for_expansion(`OPERATION_nior_n') +m4_not_for_expansion(`OPERATION_xor_n') +m4_not_for_expansion(`OPERATION_xnor_n') + +dnl popham +m4_not_for_expansion(`OPERATION_popcount') +m4_not_for_expansion(`OPERATION_hamdist') + +dnl lorrshift +m4_not_for_expansion(`OPERATION_lshift') +m4_not_for_expansion(`OPERATION_rshift') + +dnl aorslsh1_n +m4_not_for_expansion(`OPERATION_addlsh1_n') +m4_not_for_expansion(`OPERATION_sublsh1_n') +m4_not_for_expansion(`OPERATION_rsblsh1_n') + +dnl aorslsh2_n +m4_not_for_expansion(`OPERATION_addlsh2_n') +m4_not_for_expansion(`OPERATION_sublsh2_n') +m4_not_for_expansion(`OPERATION_rsblsh2_n') + +dnl rsh1aors_n +m4_not_for_expansion(`OPERATION_rsh1add_n') +m4_not_for_expansion(`OPERATION_rsh1sub_n') + + +dnl Usage: m4_config_gmp_mparam(`symbol') +dnl +dnl Check that `symbol' is defined. If it isn't, issue an error and +dnl terminate immediately. The error message explains that the symbol +dnl should be in config.m4, copied from gmp-mparam.h. +dnl +dnl Termination is immediate since missing say SQR_TOOM2_THRESHOLD can +dnl lead to infinite loops and endless error messages. + +define(m4_config_gmp_mparam, +m4_assert_numargs(1) +`ifdef(`$1',, +`m4_error(`$1 is not defined. + "configure" should have extracted this from gmp-mparam.h and put it + in config.m4 (or in _.asm for a fat binary), but somehow + this has failed. +')m4exit(1)')') + + +dnl Usage: defreg(name,reg) +dnl +dnl Give a name to a $ style register. For example, +dnl +dnl defreg(foo,$12) +dnl +dnl defreg() inserts an extra pair of quotes after the $ so that it's not +dnl interpreted as an m4 macro parameter, ie. foo is actually $`'12. m4 +dnl strips those quotes when foo is expanded. +dnl +dnl deflit() is used to make the new definition, so it will expand +dnl literally even if followed by parentheses ie. foo(99) will become +dnl $12(99). (But there's nowhere that would be used is there?) +dnl +dnl When making further definitions from existing defreg() macros, remember +dnl to use defreg() again to protect the $ in the new definitions too. For +dnl example, +dnl +dnl defreg(a0,$4) +dnl defreg(a1,$5) +dnl ... +dnl +dnl defreg(PARAM_DST,a0) +dnl +dnl This is only because a0 is expanding at the time the PARAM_DST +dnl definition is made, leaving a literal $4 that must be re-quoted. On +dnl the other hand in something like the following ra is only expanded when +dnl ret is used and its $`'31 protection will have its desired effect at +dnl that time. +dnl +dnl defreg(ra,$31) +dnl ... +dnl define(ret,`j ra') +dnl +dnl Note that only $n forms are meant to be used here, and something like +dnl 128($30) doesn't get protected and will come out wrong. + +define(defreg, +m4_assert_numargs(2) +`deflit(`$1', +substr(`$2',0,1)``''substr(`$2',1))') + + +dnl Usage: m4_instruction_wrapper() +dnl +dnl Put this, unquoted, on a line on its own, at the start of a macro +dnl that's a wrapper around an assembler instruction. It adds code to give +dnl a descriptive error message if the macro is invoked without arguments. +dnl +dnl For example, suppose jmp needs to be wrapped, +dnl +dnl define(jmp, +dnl m4_instruction_wrapper() +dnl m4_assert_numargs(1) +dnl `.byte 0x42 +dnl .long $1 +dnl nop') +dnl +dnl The point of m4_instruction_wrapper is to get a better error message +dnl than m4_assert_numargs would give if jmp is accidentally used as plain +dnl "jmp foo" instead of the intended "jmp( foo)". "jmp()" with no +dnl argument also provokes the error message. +dnl +dnl m4_instruction_wrapper should only be used with wrapped instructions +dnl that take arguments, since obviously something meant to be used as say +dnl plain "ret" doesn't want to give an error when used that way. + +define(m4_instruction_wrapper, +m4_assert_numargs(0) +``m4_instruction_wrapper_internal'(m4_doublequote($`'0),dnl +ifdef(`__file__',`m4_doublequote(__file__)',``the m4 sources''),dnl +$`#',m4_doublequote($`'1))`dnl'') + +dnl Called: m4_instruction_wrapper_internal($0,`filename',$#,$1) +define(m4_instruction_wrapper_internal, +`ifelse(eval($3<=1 && m4_length(`$4')==0),1, +`m4_error(`$1 is a macro replacing that instruction and needs arguments, see $2 for details +')')') + + +dnl Usage: m4_cpu_hex_constant(string) +dnl +dnl Expand to the string prefixed by a suitable `0x' hex marker. This +dnl should be redefined as necessary for CPUs with different conventions. + +define(m4_cpu_hex_constant, +m4_assert_numargs(1) +`0x`$1'') + + +dnl Usage: UNROLL_LOG2, UNROLL_MASK, UNROLL_BYTES +dnl CHUNK_LOG2, CHUNK_MASK, CHUNK_BYTES +dnl +dnl When code supports a variable amount of loop unrolling, the convention +dnl is to define UNROLL_COUNT to the number of limbs processed per loop. +dnl When testing code this can be varied to see how much the loop overhead +dnl is costing. For example, +dnl +dnl deflit(UNROLL_COUNT, 32) +dnl +dnl If the forloop() generating the unrolled loop has a pattern processing +dnl more than one limb, the convention is to express this with CHUNK_COUNT. +dnl For example, +dnl +dnl deflit(CHUNK_COUNT, 2) +dnl +dnl The LOG2, MASK and BYTES definitions below are derived from these COUNT +dnl definitions. If COUNT is redefined, the LOG2, MASK and BYTES follow +dnl the new definition automatically. +dnl +dnl LOG2 is the log base 2 of COUNT. MASK is COUNT-1, which can be used as +dnl a bit mask. BYTES is GMP_LIMB_BYTES*COUNT, the number of bytes +dnl processed in each unrolled loop. +dnl +dnl GMP_LIMB_BYTES is defined in a CPU specific m4 include file. It +dnl exists only so the BYTES definitions here can be common to all CPUs. +dnl In the actual code for a given CPU, an explicit 4 or 8 may as well be +dnl used because the code is only for a particular CPU, it doesn't need to +dnl be general. +dnl +dnl Note that none of these macros do anything except give conventional +dnl names to commonly used things. You still have to write your own +dnl expressions for a forloop() and the resulting address displacements. +dnl Something like the following would be typical for 4 bytes per limb. +dnl +dnl forloop(`i',0,UNROLL_COUNT-1,` +dnl deflit(`disp',eval(i*4)) +dnl ... +dnl ') +dnl +dnl Or when using CHUNK_COUNT, +dnl +dnl forloop(`i',0,UNROLL_COUNT/CHUNK_COUNT-1,` +dnl deflit(`disp0',eval(i*CHUNK_COUNT*4)) +dnl deflit(`disp1',eval(disp0+4)) +dnl ... +dnl ') +dnl +dnl Clearly `i' can be run starting from 1, or from high to low or whatever +dnl best suits. + +deflit(UNROLL_LOG2, +m4_assert_defined(`UNROLL_COUNT') +`m4_log2(UNROLL_COUNT)') + +deflit(UNROLL_MASK, +m4_assert_defined(`UNROLL_COUNT') +`eval(UNROLL_COUNT-1)') + +deflit(UNROLL_BYTES, +m4_assert_defined(`UNROLL_COUNT') +m4_assert_defined(`GMP_LIMB_BYTES') +`eval(UNROLL_COUNT * GMP_LIMB_BYTES)') + +deflit(CHUNK_LOG2, +m4_assert_defined(`CHUNK_COUNT') +`m4_log2(CHUNK_COUNT)') + +deflit(CHUNK_MASK, +m4_assert_defined(`CHUNK_COUNT') +`eval(CHUNK_COUNT-1)') + +deflit(CHUNK_BYTES, +m4_assert_defined(`CHUNK_COUNT') +m4_assert_defined(`GMP_LIMB_BYTES') +`eval(CHUNK_COUNT * GMP_LIMB_BYTES)') + + +dnl Usage: MPN(name) +dnl +dnl Add MPN_PREFIX to a name. +dnl MPN_PREFIX defaults to "__gmpn_" if not defined. +dnl +dnl m4_unquote is used in MPN so that when it expands to say __gmpn_foo, +dnl that identifier will be subject to further macro expansion. This is +dnl used by some of the fat binary support for renaming symbols. + +ifdef(`MPN_PREFIX',, +`define(`MPN_PREFIX',`__gmpn_')') + +define(MPN, +m4_assert_numargs(1) +`m4_unquote(MPN_PREFIX`'$1)') + + +dnl Usage: mpn_add_n, etc +dnl +dnl Convenience definitions using MPN(), like the #defines in gmp.h. Each +dnl function that might be implemented in assembler is here. + +define(define_mpn, +m4_assert_numargs(1) +`deflit(`mpn_$1',`MPN(`$1')')') + +define_mpn(add) +define_mpn(add_1) +define_mpn(add_err1_n) +define_mpn(add_err2_n) +define_mpn(add_err3_n) +define_mpn(add_n) +define_mpn(add_nc) +define_mpn(addlsh1_n) +define_mpn(addlsh1_nc) +define_mpn(addlsh2_n) +define_mpn(addlsh2_nc) +define_mpn(addlsh_n) +define_mpn(addlsh_nc) +define_mpn(addlsh1_n_ip1) +define_mpn(addlsh1_nc_ip1) +define_mpn(addlsh2_n_ip1) +define_mpn(addlsh2_nc_ip1) +define_mpn(addlsh_n_ip1) +define_mpn(addlsh_nc_ip1) +define_mpn(addlsh1_n_ip2) +define_mpn(addlsh1_nc_ip2) +define_mpn(addlsh2_n_ip2) +define_mpn(addlsh2_nc_ip2) +define_mpn(addlsh_n_ip2) +define_mpn(addlsh_nc_ip2) +define_mpn(addmul_1) +define_mpn(addmul_1c) +define_mpn(addmul_2) +define_mpn(addmul_3) +define_mpn(addmul_4) +define_mpn(addmul_5) +define_mpn(addmul_6) +define_mpn(addmul_7) +define_mpn(addmul_8) +define_mpn(addmul_2s) +define_mpn(add_n_sub_n) +define_mpn(add_n_sub_nc) +define_mpn(addaddmul_1msb0) +define_mpn(and_n) +define_mpn(andn_n) +define_mpn(bdiv_q_1) +define_mpn(pi1_bdiv_q_1) +define_mpn(bdiv_dbm1c) +define_mpn(cmp) +define_mpn(cnd_add_n) +define_mpn(cnd_sub_n) +define_mpn(com) +define_mpn(copyd) +define_mpn(copyi) +define_mpn(count_leading_zeros) +define_mpn(count_trailing_zeros) +define_mpn(div_qr_1n_pi1) +define_mpn(div_qr_2) +define_mpn(div_qr_2n_pi1) +define_mpn(div_qr_2u_pi1) +define_mpn(div_qr_2n_pi2) +define_mpn(div_qr_2u_pi2) +define_mpn(divexact_1) +define_mpn(divexact_by3c) +define_mpn(divrem) +define_mpn(divrem_1) +define_mpn(divrem_1c) +define_mpn(divrem_2) +define_mpn(divrem_classic) +define_mpn(divrem_newton) +define_mpn(dump) +define_mpn(gcd) +define_mpn(gcd_1) +define_mpn(gcd_11) +define_mpn(gcd_22) +define_mpn(gcdext) +define_mpn(get_str) +define_mpn(hamdist) +define_mpn(invert_limb) +define_mpn(invert_limb_table) +define_mpn(ior_n) +define_mpn(iorn_n) +define_mpn(lshift) +define_mpn(lshiftc) +define_mpn(mod_1_1p) +define_mpn(mod_1_1p_cps) +define_mpn(mod_1s_2p) +define_mpn(mod_1s_2p_cps) +define_mpn(mod_1s_3p) +define_mpn(mod_1s_3p_cps) +define_mpn(mod_1s_4p) +define_mpn(mod_1s_4p_cps) +define_mpn(mod_1) +define_mpn(mod_1c) +define_mpn(mod_34lsub1) +define_mpn(modexact_1_odd) +define_mpn(modexact_1c_odd) +define_mpn(mul) +define_mpn(mul_1) +define_mpn(mul_1c) +define_mpn(mul_2) +define_mpn(mul_3) +define_mpn(mul_4) +define_mpn(mul_5) +define_mpn(mul_6) +define_mpn(mul_basecase) +define_mpn(mul_n) +define_mpn(mullo_basecase) +define_mpn(mulmid_basecase) +define_mpn(perfect_square_p) +define_mpn(popcount) +define_mpn(preinv_divrem_1) +define_mpn(preinv_mod_1) +define_mpn(nand_n) +define_mpn(neg) +define_mpn(nior_n) +define_mpn(powm) +define_mpn(powlo) +define_mpn(random) +define_mpn(random2) +define_mpn(redc_1) +define_mpn(redc_2) +define_mpn(rsblsh1_n) +define_mpn(rsblsh1_nc) +define_mpn(rsblsh2_n) +define_mpn(rsblsh2_nc) +define_mpn(rsblsh_n) +define_mpn(rsblsh_nc) +define_mpn(rsh1add_n) +define_mpn(rsh1add_nc) +define_mpn(rsh1sub_n) +define_mpn(rsh1sub_nc) +define_mpn(rshift) +define_mpn(rshiftc) +define_mpn(sbpi1_bdiv_q) +define_mpn(sbpi1_bdiv_qr) +define_mpn(sbpi1_bdiv_r) +define_mpn(scan0) +define_mpn(scan1) +define_mpn(set_str) +define_mpn(sqr_basecase) +define_mpn(sqr_diagonal) +define_mpn(sqr_diag_addlsh1) +define_mpn(sub_n) +define_mpn(sublsh1_n) +define_mpn(sublsh1_nc) +define_mpn(sublsh1_n_ip1) +define_mpn(sublsh1_nc_ip1) +define_mpn(sublsh2_n) +define_mpn(sublsh2_nc) +define_mpn(sublsh2_n_ip1) +define_mpn(sublsh2_nc_ip1) +define_mpn(sublsh_n) +define_mpn(sublsh_nc) +define_mpn(sublsh_n_ip1) +define_mpn(sublsh_nc_ip1) +define_mpn(sqrtrem) +define_mpn(sub) +define_mpn(sub_1) +define_mpn(sub_err1_n) +define_mpn(sub_err2_n) +define_mpn(sub_err3_n) +define_mpn(sub_n) +define_mpn(sub_nc) +define_mpn(submul_1) +define_mpn(submul_1c) +define_mpn(sec_tabselect) +define_mpn(umul_ppmm) +define_mpn(umul_ppmm_r) +define_mpn(udiv_qrnnd) +define_mpn(udiv_qrnnd_r) +define_mpn(xnor_n) +define_mpn(xor_n) + + +dnl Defines for C global arrays and variables, with names matching what's +dnl used in the C code. +dnl +dnl Notice that GSYM_PREFIX is included, unlike with the function defines +dnl above. Also, "deflit" is used so that something like __clz_tab(%ebx) +dnl comes out as __gmpn_clz_tab(%ebx), for the benefit of CPUs with that +dnl style assembler syntax. + +deflit(__clz_tab, +m4_assert_defined(`GSYM_PREFIX') +`GSYM_PREFIX`'MPN(`clz_tab')') + +deflit(binvert_limb_table, +m4_assert_defined(`GSYM_PREFIX') +`GSYM_PREFIX`'__gmp_binvert_limb_table') + + +dnl Usage: ASM_START() +dnl +dnl Emit any directives needed once at the start of an assembler file, like +dnl ".set noreorder" or whatever. The default for this is nothing, but +dnl it's redefined by CPU specific m4 files. + +define(ASM_START) + + +dnl Usage: ASM_END() +dnl +dnl Emit any directives needed once at the end of an assembler file. The +dnl default for this is nothing, but it's redefined by CPU specific m4 files. + +define(ASM_END) + + +dnl Usage: PROLOGUE(foo[,param]) +dnl EPILOGUE(foo) +dnl +dnl Emit directives to start or end a function. GSYM_PREFIX is added by +dnl these macros if necessary, so the given "foo" is what the function will +dnl be called in C. +dnl +dnl The second parameter to PROLOGUE is used only for some CPUs and should +dnl be omitted if not required. +dnl +dnl Nested or overlapping PROLOGUE/EPILOGUE pairs are allowed, if that +dnl makes sense for the system. The name given to EPILOGUE must be a +dnl currently open PROLOGUE. +dnl +dnl If only one PROLOGUE is open then the name can be omitted from +dnl EPILOGUE. This is encouraged, since it means the name only has to +dnl appear in one place, not two. +dnl +dnl The given name "foo" is not fully quoted here, it will be macro +dnl expanded more than once. This is the way the m4_list macros work, and +dnl it also helps the tune/many.pl program do a renaming like +dnl -D__gmpn_add_n=mpn_add_n_foo when GSYM_PREFIX is not empty. + +define(PROLOGUE, +m4_assert_numargs_range(1,2) +`m4_file_seen()dnl +define(`PROLOGUE_list',m4_list_quote($1,PROLOGUE_list))dnl +ifelse(`$2',, +`PROLOGUE_cpu(GSYM_PREFIX`'$1)', +`PROLOGUE_cpu(GSYM_PREFIX`'$1,`$2')')') + +define(EPILOGUE, +m4_assert_numargs_range(0,1) +`ifelse(`$1',, +`ifelse(m4_list_count(PROLOGUE_list),0, +`m4_error(`no open functions for EPILOGUE +')', +`ifelse(m4_list_count(PROLOGUE_list),1, +`EPILOGUE_internal(PROLOGUE_current_function)', +`m4_error(`more than one open function for EPILOGUE +')')')', +`EPILOGUE_internal(`$1')')') + +define(EPILOGUE_internal, +m4_assert_numargs(1) +m4_assert_defined(`EPILOGUE_cpu') +`ifelse(m4_list_find($1,PROLOGUE_list),0, +`m4_error(`EPILOGUE without PROLOGUE: $1 +')')dnl +define(`PROLOGUE_list',m4_list_quote(m4_list_remove($1,PROLOGUE_list)))dnl +EPILOGUE_cpu(GSYM_PREFIX`$1')') + +dnl Currently open PROLOGUEs, as a comma-separated list. +define(PROLOGUE_list) + + +dnl Called: PROLOGUE_check(list,...) +dnl Check there's no remaining open PROLOGUEs at the end of input. +define(PROLOGUE_check, +`ifelse($1,,, +`m4_error(`no EPILOGUE for: $1 +')dnl +PROLOGUE_check(shift($@))')') + +m4wrap_prepend(`PROLOGUE_check(PROLOGUE_list)') + + +dnl Usage: PROLOGUE_current_function +dnl +dnl This macro expands to the current PROLOGUE/EPILOGUE function, or the +dnl most recent PROLOGUE if such pairs are nested or overlapped. + +define(PROLOGUE_current_function, +m4_assert_numargs(-1) +`m4_list_first(PROLOGUE_list)') + + +dnl Usage: PROLOGUE_cpu(GSYM_PREFIX`'foo[,param]) +dnl EPILOGUE_cpu(GSYM_PREFIX`'foo) +dnl +dnl These macros hold the CPU-specific parts of PROLOGUE and EPILOGUE. +dnl Both are called with the function name, with GSYM_PREFIX already +dnl prepended. +dnl +dnl The definitions here are something typical and sensible, but CPU or +dnl system specific m4 files should redefine them as necessary. The +dnl optional extra parameter to PROLOGUE_cpu is not expected and not +dnl accepted here. + +define(PROLOGUE_cpu, +m4_assert_numargs(1) +` TEXT + ALIGN(8) + GLOBL `$1' GLOBL_ATTR + TYPE(`$1',`function') +`$1'LABEL_SUFFIX') + +define(EPILOGUE_cpu, +` SIZE(`$1',.-`$1')') + + +dnl Usage: L(name) +dnl +dnl Generate a local label with the given name. This is simply a +dnl convenient way to add LSYM_PREFIX. +dnl +dnl LSYM_PREFIX might be L$, so defn() must be used to quote it or the L +dnl will expand again as the L macro, making an infinite recursion. + +define(`L', +m4_assert_numargs(1) +`defn(`LSYM_PREFIX')$1') + + +dnl Usage: LDEF(name) +dnl +dnl Generate a directive to define a local label. +dnl +dnl On systems with a fixed syntax for defining labels there's no need to +dnl use this macro, it's only meant for systems where the syntax varies, +dnl like hppa which is "L(foo):" with gas, but just "L(foo)" in column 0 +dnl with the system `as'. +dnl +dnl The extra `' after LABEL_SUFFIX avoids any chance of a following +dnl "(...)" being interpreted as an argument list. Not that it'd be +dnl sensible to write anything like that after an LDEF(), but just in case. + +define(LDEF, +m4_assert_numargs(1) +m4_assert_defined(`LABEL_SUFFIX') +`L(`$1')`'LABEL_SUFFIX`'') + + +dnl Usage: INT32(label,value) +dnl INT64(label,first,second) + +define(`INT32', +m4_assert_defined(`W32') +` ALIGN(4) +LDEF(`$1') + W32 $2') + +define(`INT64', +m4_assert_defined(`W32') +` ALIGN(8) +LDEF(`$1') + W32 $2 + W32 $3') + + +dnl Usage: ALIGN(bytes) +dnl +dnl Emit a ".align" directive. The alignment is specified in bytes, and +dnl will normally need to be a power of 2. The actual ".align" generated +dnl is either bytes or logarithmic according to what ./configure finds the +dnl assembler needs. +dnl +dnl If ALIGN_FILL_0x90 is defined and equal to "yes", then ", 0x90" is +dnl appended. This is for x86, see mpn/x86/README. + +define(ALIGN, +m4_assert_numargs(1) +m4_assert_defined(`ALIGN_LOGARITHMIC') +`.align ifelse(ALIGN_LOGARITHMIC,yes,`m4_log2($1)',`eval($1)')dnl +ifelse(ALIGN_FILL_0x90,yes,`, 0x90')') + + +dnl Usage: MULFUNC_PROLOGUE(function function...) +dnl +dnl A dummy macro which is grepped for by ./configure to know what +dnl functions a multi-function file is providing. Use this if there aren't +dnl explicit PROLOGUE()s for each possible function. +dnl +dnl Multiple MULFUNC_PROLOGUEs can be used, or just one with the function +dnl names separated by spaces. + +define(`MULFUNC_PROLOGUE', +m4_assert_numargs(1) +) + + +dnl Usage: NAILS_SUPPORT(spec spec ...) +dnl +dnl A dummy macro which is grepped for by ./configure to know what nails +dnl are supported in an asm file. +dnl +dnl Ranges can be given, or just individual values. Multiple values or +dnl ranges can be given, separated by spaces. Multiple NAILS_SUPPORT +dnl declarations work too. Some examples, +dnl +dnl NAILS_SUPPORT(1-20) +dnl NAILS_SUPPORT(1 6 9-12) +dnl NAILS_SUPPORT(1-10 16-20) + +define(NAILS_SUPPORT, +m4_assert_numargs(1) +) + + +dnl Usage: ABI_SUPPORT(abi) +dnl +dnl A dummy macro which is grepped for by ./configure to know what ABIs +dnl are supported in an asm file. +dnl +dnl If multiple non-standard ABIs are supported, several ABI_SUPPORT +dnl declarations should be used: +dnl +dnl ABI_SUPPORT(FOOABI) +dnl ABI_SUPPORT(BARABI) + +define(ABI_SUPPORT, +m4_assert_numargs(1) +) + + +dnl Usage: GMP_NUMB_MASK +dnl +dnl A bit mask for the number part of a limb. Eg. with 6 bit nails in a +dnl 32 bit limb, GMP_NUMB_MASK would be 0x3ffffff. + +define(GMP_NUMB_MASK, +m4_assert_numargs(-1) +m4_assert_defined(`GMP_NUMB_BITS') +`m4_hex_lowmask(GMP_NUMB_BITS)') + + +dnl Usage: m4append(`variable',`value-to-append') + +define(`m4append', +`define(`$1', defn(`$1')`$2') +' +) + +divert`'dnl -- cgit v1.2.3