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)