1674 lines
52 KiB
Plaintext
1674 lines
52 KiB
Plaintext
divert(-1)
|
|
dnl
|
|
dnl m4 macros for gmp assembly code, shared by all CPUs.
|
|
|
|
dnl Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
|
|
dnl Foundation, Inc.
|
|
dnl
|
|
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
|
|
dnl modify it under the terms of the GNU Lesser General Public License as
|
|
dnl published by the Free Software Foundation; either version 2.1 of the
|
|
dnl License, or (at your option) any later version.
|
|
dnl
|
|
dnl The GNU MP Library is distributed in the hope that it will be useful,
|
|
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
dnl Lesser General Public License for more details.
|
|
dnl
|
|
dnl You should have received a copy of the GNU Lesser General Public
|
|
dnl License along with the GNU MP Library; see the file COPYING.LIB. If
|
|
dnl not, write to the Free Software Foundation, Inc., 51 Franklin Street,
|
|
dnl Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
|
|
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, supressing 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 exapanded 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-incl.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 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')
|
|
|
|
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_KARATSUBA_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 <cpu>_<file>.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 BYTES_PER_MP_LIMB*COUNT, the number of bytes
|
|
dnl processed in each unrolled loop.
|
|
dnl
|
|
dnl BYTES_PER_MP_LIMB 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(`BYTES_PER_MP_LIMB')
|
|
`eval(UNROLL_COUNT * BYTES_PER_MP_LIMB)')
|
|
|
|
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(`BYTES_PER_MP_LIMB')
|
|
`eval(CHUNK_COUNT * BYTES_PER_MP_LIMB)')
|
|
|
|
|
|
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 mpir.h. Each
|
|
dnl function that might be implemented in assembler is here.
|
|
|
|
define(define_mpn,
|
|
m4_assert_numargs(1)
|
|
`define(`mpn_$1',`MPN(`$1')')')
|
|
|
|
define_mpn(add)
|
|
define_mpn(add_1)
|
|
define_mpn(add_err1_n)
|
|
define_mpn(add_err2_n)
|
|
define_mpn(add_n)
|
|
define_mpn(add_nc)
|
|
define_mpn(addadd_n)
|
|
define_mpn(addlsh_n)
|
|
define_mpn(addlsh_nc)
|
|
define_mpn(addlsh1_n)
|
|
define_mpn(addmul_1)
|
|
define_mpn(addmul_1c)
|
|
define_mpn(addmul_2)
|
|
define_mpn(addmul_3)
|
|
define_mpn(addmul_4)
|
|
define_mpn(addsub_n)
|
|
define_mpn(sumdiff_n)
|
|
define_mpn(sumdiff_nc)
|
|
define_mpn(and_n)
|
|
define_mpn(andn_n)
|
|
define_mpn(bdivmod)
|
|
define_mpn(cmp)
|
|
define_mpn(com_n)
|
|
define_mpn(copyd)
|
|
define_mpn(copyi)
|
|
define_mpn(count_leading_zeros)
|
|
define_mpn(count_trailing_zeros)
|
|
define_mpn(declsh_n)
|
|
define_mpn(divexact_1)
|
|
define_mpn(divexact_by3c)
|
|
define_mpn(divexact_byff)
|
|
define_mpn(divexact_byBm1of)
|
|
define_mpn(divrem_1)
|
|
define_mpn(divrem_euclidean_qr_1)
|
|
define_mpn(divrem_euclidean_qr_2)
|
|
define_mpn(divrem_euclidean_r_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_finda)
|
|
define_mpn(gcdext)
|
|
define_mpn(get_str)
|
|
define_mpn(hamdist)
|
|
define_mpn(inclsh_n)
|
|
define_mpn(invert_limb)
|
|
define_mpn(ior_n)
|
|
define_mpn(iorn_n)
|
|
define_mpn(kara_mul_n)
|
|
define_mpn(kara_sqr_n)
|
|
define_mpn(lshift)
|
|
define_mpn(lshift1)
|
|
define_mpn(lshift2)
|
|
define_mpn(lshiftc)
|
|
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_basecase)
|
|
define_mpn(mul_n)
|
|
define_mpn(mullow_n_basecase)
|
|
define_mpn(mullow_basecase)
|
|
define_mpn(mulmid_basecase)
|
|
define_mpn(mulshort_n_basecase)
|
|
define_mpn(neg_n)
|
|
define_mpn(perfect_square_p)
|
|
define_mpn(popcount)
|
|
define_mpn(preinv_divrem_1)
|
|
define_mpn(preinv_mod_1)
|
|
define_mpn(nand_n)
|
|
define_mpn(nior_n)
|
|
define_mpn(random)
|
|
define_mpn(random2)
|
|
define_mpn(redc_basecase)
|
|
define_mpn(rsh1add_n)
|
|
define_mpn(rsh1sub_n)
|
|
define_mpn(rshift)
|
|
define_mpn(rshift1)
|
|
define_mpn(rshift2)
|
|
define_mpn(rshiftc)
|
|
define_mpn(scan0)
|
|
define_mpn(scan1)
|
|
define_mpn(set_str)
|
|
define_mpn(sqr_basecase)
|
|
define_mpn(sqr_diagonal)
|
|
define_mpn(sub_err1_n)
|
|
define_mpn(sub_err2_n)
|
|
define_mpn(sub_n)
|
|
define_mpn(sublsh_n)
|
|
define_mpn(sublsh_nc)
|
|
define_mpn(sublsh1_n)
|
|
define_mpn(sqrtrem)
|
|
define_mpn(store)
|
|
define_mpn(sub)
|
|
define_mpn(sub_1)
|
|
define_mpn(sub_n)
|
|
define_mpn(sub_nc)
|
|
define_mpn(subadd_n)
|
|
define_mpn(submul_1)
|
|
define_mpn(submul_1c)
|
|
define_mpn(toom3_mul_n)
|
|
define_mpn(toom3_sqr_n)
|
|
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(modlimb_invert_table,
|
|
m4_assert_defined(`GSYM_PREFIX')
|
|
`GSYM_PREFIX`'__gmp_modlimb_invert_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: 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)')
|
|
|
|
|
|
divert`'dnl
|