asm-defs.m4
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:52k
源码类别:

数学计算

开发平台:

Unix_Linux

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