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

数学计算

开发平台:

Unix_Linux

  1. divert(-1)
  2. dnl  m4 macros for x86 assembler.
  3. dnl  Copyright 1999, 2000, 2001, 2002, 2003, 2007 Free Software Foundation,
  4. dnl  Inc.
  5. dnl
  6. dnl  This file is part of the GNU MP Library.
  7. dnl
  8. dnl  The GNU MP Library is free software; you can redistribute it and/or
  9. dnl  modify it under the terms of the GNU Lesser General Public License as
  10. dnl  published by the Free Software Foundation; either version 3 of the
  11. dnl  License, or (at your option) any later version.
  12. dnl
  13. dnl  The GNU MP Library is distributed in the hope that it will be useful,
  14. dnl  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16. dnl  Lesser General Public License for more details.
  17. dnl
  18. dnl  You should have received a copy of the GNU Lesser General Public License
  19. dnl  along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  20. dnl  Notes:
  21. dnl
  22. dnl  m4 isn't perfect for processing BSD style x86 assembler code, the main
  23. dnl  problems are,
  24. dnl
  25. dnl  1. Doing define(foo,123) and then using foo in an addressing mode like
  26. dnl     foo(%ebx) expands as a macro rather than a constant.  This is worked
  27. dnl     around by using deflit() from asm-defs.m4, instead of define().
  28. dnl
  29. dnl  2. Immediates in macro definitions need a space or `' to stop the $
  30. dnl     looking like a macro parameter.  For example,
  31. dnl
  32. dnl         define(foo, `mov $ 123, %eax')
  33. dnl
  34. dnl     This is only a problem in macro definitions, not in ordinary text,
  35. dnl     and not in macro parameters like text passed to forloop() or ifdef().
  36. deflit(BYTES_PER_MP_LIMB, 4)
  37. dnl  Libtool gives -DPIC -DDLL_EXPORT to indicate a cygwin or mingw DLL.  We
  38. dnl  undefine PIC since we don't need to be position independent in this
  39. dnl  case and definitely don't want the ELF style _GLOBAL_OFFSET_TABLE_ etc.
  40. ifdef(`DLL_EXPORT',`undefine(`PIC')')
  41. dnl  Usage: CPUVEC_FUNCS_LIST
  42. dnl
  43. dnl  A list of the functions from gmp-impl.h x86 struct cpuvec_t, in the
  44. dnl  order they appear in that structure.
  45. define(CPUVEC_FUNCS_LIST,
  46. ``add_n',
  47. `addmul_1',
  48. `copyd',
  49. `copyi',
  50. `divexact_1',
  51. `divexact_by3c',
  52. `divrem_1',
  53. `gcd_1',
  54. `lshift',
  55. `mod_1',
  56. `mod_34lsub1',
  57. `modexact_1c_odd',
  58. `mul_1',
  59. `mul_basecase',
  60. `preinv_divrem_1',
  61. `preinv_mod_1',
  62. `rshift',
  63. `sqr_basecase',
  64. `sub_n',
  65. `submul_1'')
  66. dnl  Called: PROLOGUE_cpu(GSYM_PREFIX`'foo)
  67. dnl
  68. dnl  In the x86 code we use explicit TEXT and ALIGN() calls in the code,
  69. dnl  since different alignments are wanted in various circumstances.  So for
  70. dnl  instance,
  71. dnl
  72. dnl                  TEXT
  73. dnl                  ALIGN(16)
  74. dnl          PROLOGUE(mpn_add_n)
  75. dnl          ...
  76. dnl          EPILOGUE()
  77. define(`PROLOGUE_cpu',
  78. m4_assert_numargs(1)
  79. m4_assert_defined(`WANT_PROFILING')
  80. `GLOBL $1
  81. TYPE($1,`function')
  82. COFF_TYPE($1)
  83. $1:
  84. ifelse(WANT_PROFILING,`prof',      ` call_mcount')
  85. ifelse(WANT_PROFILING,`gprof',     ` call_mcount')
  86. ifelse(WANT_PROFILING,`instrument',` call_instrument(enter)')
  87. ')
  88. dnl  Usage: COFF_TYPE(GSYM_PREFIX`'foo)
  89. dnl
  90. dnl  Emit COFF style ".def ... .endef" type information for a function, when
  91. dnl  supported.  The argument should include any GSYM_PREFIX.
  92. dnl
  93. dnl  See autoconf macro GMP_ASM_COFF_TYPE for HAVE_COFF_TYPE.
  94. define(COFF_TYPE,
  95. m4_assert_numargs(1)
  96. m4_assert_defined(`HAVE_COFF_TYPE')
  97. `ifelse(HAVE_COFF_TYPE,yes,
  98. `.def $1
  99. .scl 2
  100. .type 32
  101. .endef')')
  102. dnl  Usage: call_mcount
  103. dnl
  104. dnl  For `gprof' style profiling, %ebp is setup as a frame pointer.  None of
  105. dnl  the assembler routines use %ebp this way, so it's done only for the
  106. dnl  benefit of mcount.  glibc sysdeps/i386/i386-mcount.S shows how mcount
  107. dnl  gets the current function from (%esp) and the parent from 4(%ebp).
  108. dnl
  109. dnl  For `prof' style profiling gcc generates mcount calls without setting
  110. dnl  up %ebp, and the same is done here.
  111. define(`call_mcount',
  112. m4_assert_numargs(-1)
  113. m4_assert_defined(`WANT_PROFILING')
  114. m4_assert_defined(`MCOUNT_PIC_REG')
  115. m4_assert_defined(`MCOUNT_NONPIC_REG')
  116. m4_assert_defined(`MCOUNT_PIC_CALL')
  117. m4_assert_defined(`MCOUNT_NONPIC_CALL')
  118. `ifelse(ifdef(`PIC',`MCOUNT_PIC_REG',`MCOUNT_NONPIC_REG'),,,
  119. ` DATA
  120. ALIGN(4)
  121. L(mcount_data_`'mcount_counter):
  122. W32 0
  123. TEXT
  124. ')dnl
  125. ifelse(WANT_PROFILING,`gprof',
  126. ` pushl %ebp
  127. movl %esp, %ebp
  128. ')dnl
  129. ifdef(`PIC',
  130. ` pushl %ebx
  131. call_movl_eip_to_ebx
  132. L(mcount_here_`'mcount_counter):
  133. addl $_GLOBAL_OFFSET_TABLE_+[.-L(mcount_here_`'mcount_counter)], %ebx
  134. ifelse(MCOUNT_PIC_REG,,,
  135. ` leal L(mcount_data_`'mcount_counter)@GOTOFF(%ebx), MCOUNT_PIC_REG')
  136. MCOUNT_PIC_CALL
  137. popl %ebx
  138. ',`dnl non-PIC
  139. ifelse(MCOUNT_NONPIC_REG,,,
  140. ` movl `$'L(mcount_data_`'mcount_counter), MCOUNT_NONPIC_REG
  141. ')dnl
  142. MCOUNT_NONPIC_CALL
  143. ')dnl
  144. ifelse(WANT_PROFILING,`gprof',
  145. ` popl %ebp
  146. ')
  147. define(`mcount_counter',incr(mcount_counter))
  148. ')
  149. define(mcount_counter,1)
  150. dnl  Usage: call_instrument(enter|exit)
  151. dnl
  152. dnl  Call __cyg_profile_func_enter or __cyg_profile_func_exit.
  153. dnl
  154. dnl  For PIC, most routines don't require _GLOBAL_OFFSET_TABLE_ themselves
  155. dnl  so %ebx is just setup for these calls.  It's a bit wasteful to repeat
  156. dnl  the setup for the exit call having done it earlier for the enter, but
  157. dnl  there's nowhere very convenient to hold %ebx through the length of a
  158. dnl  routine, in general.
  159. dnl
  160. dnl  For PIC, because instrument_current_function will be within the current
  161. dnl  object file we can get it just as an offset from %eip, there's no need
  162. dnl  to use the GOT.
  163. dnl
  164. dnl  No attempt is made to maintain the stack alignment gcc generates with
  165. dnl  -mpreferred-stack-boundary.  This wouldn't be hard, but it seems highly
  166. dnl  unlikely the instrumenting functions would be doing anything that'd
  167. dnl  benefit from alignment, in particular they're unlikely to be using
  168. dnl  doubles or long doubles on the stack.
  169. dnl
  170. dnl  The FRAME scheme is used to conveniently account for the register saves
  171. dnl  before accessing the return address.  Any previous value is saved and
  172. dnl  restored, since plenty of code keeps a value across a "ret" in the
  173. dnl  middle of a routine.
  174. define(call_instrument,
  175. m4_assert_numargs(1)
  176. ` pushdef(`FRAME',0)
  177. ifelse($1,exit,
  178. ` pushl %eax FRAME_pushl() C return value
  179. ')
  180. ifdef(`PIC',
  181. ` pushl %ebx FRAME_pushl()
  182. call_movl_eip_to_ebx
  183. L(instrument_here_`'instrument_count):
  184. movl %ebx, %ecx
  185. addl $_GLOBAL_OFFSET_TABLE_+[.-L(instrument_here_`'instrument_count)], %ebx
  186. C use addl rather than leal to avoid old gas bugs, see mpn/x86/README
  187. addl $instrument_current_function-L(instrument_here_`'instrument_count), %ecx
  188. pushl m4_empty_if_zero(FRAME)(%esp) FRAME_pushl() C return addr
  189. pushl %ecx FRAME_pushl() C this function
  190. call GSYM_PREFIX`'__cyg_profile_func_$1@PLT
  191. addl $`'8, %esp
  192. popl %ebx
  193. ',
  194. ` C non-PIC
  195. pushl m4_empty_if_zero(FRAME)(%esp) FRAME_pushl() C return addr
  196. pushl $instrument_current_function FRAME_pushl() C this function
  197. call GSYM_PREFIX`'__cyg_profile_func_$1
  198. addl $`'8, %esp
  199. ')
  200. ifelse($1,exit,
  201. ` popl %eax C return value
  202. ')
  203. popdef(`FRAME')
  204. define(`instrument_count',incr(instrument_count))
  205. ')
  206. define(instrument_count,1)
  207. dnl  Usage: instrument_current_function
  208. dnl
  209. dnl  Return the current function name for instrumenting purposes.  This is
  210. dnl  PROLOGUE_current_function, but it sticks at the first such name seen.
  211. dnl
  212. dnl  Sticking to the first name seen ensures that multiple-entrypoint
  213. dnl  functions like mpn_add_nc and mpn_add_n will make enter and exit calls
  214. dnl  giving the same function address.
  215. define(instrument_current_function,
  216. m4_assert_numargs(-1)
  217. `ifdef(`instrument_current_function_seen',
  218. `instrument_current_function_seen',
  219. `define(`instrument_current_function_seen',PROLOGUE_current_function)dnl
  220. PROLOGUE_current_function')')
  221. dnl  Usage: call_movl_eip_to_ebx
  222. dnl
  223. dnl  Generate a call to L(movl_eip_to_ebx), and record the need for that
  224. dnl  routine.
  225. define(call_movl_eip_to_ebx,
  226. m4_assert_numargs(-1)
  227. `call L(movl_eip_to_ebx)
  228. define(`movl_eip_to_ebx_needed',1)')
  229. dnl  Usage: generate_movl_eip_to_ebx
  230. dnl
  231. dnl  Emit a L(movl_eip_to_ebx) routine, if needed and not already generated.
  232. define(generate_movl_eip_to_ebx,
  233. m4_assert_numargs(-1)
  234. `ifelse(movl_eip_to_ebx_needed,1,
  235. `ifelse(movl_eip_to_ebx_done,1,,
  236. `L(movl_eip_to_ebx):
  237. movl (%esp), %ebx
  238. ret_internal
  239. define(`movl_eip_to_ebx_done',1)
  240. ')')')
  241. dnl  Usage: ret
  242. dnl
  243. dnl  Generate a "ret", but if doing instrumented profiling then call
  244. dnl  __cyg_profile_func_exit first.
  245. define(ret,
  246. m4_assert_numargs(-1)
  247. m4_assert_defined(`WANT_PROFILING')
  248. `ifelse(WANT_PROFILING,instrument,
  249. `ret_instrument',
  250. `ret_internal')
  251. generate_movl_eip_to_ebx
  252. ')
  253. dnl  Usage: ret_internal
  254. dnl
  255. dnl  A plain "ret", without any __cyg_profile_func_exit call.  This can be
  256. dnl  used for a return which is internal to some function, such as when
  257. dnl  getting %eip for PIC.
  258. define(ret_internal,
  259. m4_assert_numargs(-1)
  260. ``ret'')
  261. dnl  Usage: ret_instrument
  262. dnl
  263. dnl  Generate call to __cyg_profile_func_exit and then a ret.  If a ret has
  264. dnl  already been seen from this function then jump to that chunk of code,
  265. dnl  rather than emitting it again.
  266. define(ret_instrument,
  267. m4_assert_numargs(-1)
  268. `ifelse(m4_unquote(ret_instrument_seen_`'instrument_current_function),1,
  269. `jmp L(instrument_exit_`'instrument_current_function)',
  270. `define(ret_instrument_seen_`'instrument_current_function,1)
  271. L(instrument_exit_`'instrument_current_function):
  272. call_instrument(exit)
  273. ret_internal')')
  274. dnl  Usage: _GLOBAL_OFFSET_TABLE_
  275. dnl
  276. dnl  Expand to _GLOBAL_OFFSET_TABLE_ plus any necessary underscore prefix.
  277. dnl  This lets us write plain _GLOBAL_OFFSET_TABLE_ in SVR4 style, but still
  278. dnl  work with systems requiring an extra underscore such as OpenBSD.
  279. dnl
  280. dnl  deflit is used so "leal _GLOBAL_OFFSET_TABLE_(%eax), %ebx" will come
  281. dnl  out right, though that form doesn't work properly in gas (see
  282. dnl  mpn/x86/README).
  283. deflit(_GLOBAL_OFFSET_TABLE_,
  284. m4_assert_defined(`GOT_GSYM_PREFIX')
  285. `GOT_GSYM_PREFIX`_GLOBAL_OFFSET_TABLE_'')
  286. dnl  --------------------------------------------------------------------------
  287. dnl  Various x86 macros.
  288. dnl
  289. dnl  Usage: ALIGN_OFFSET(bytes,offset)
  290. dnl
  291. dnl  Align to `offset' away from a multiple of `bytes'.
  292. dnl
  293. dnl  This is useful for testing, for example align to something very strict
  294. dnl  and see what effect offsets from it have, "ALIGN_OFFSET(256,32)".
  295. dnl
  296. dnl  Generally you wouldn't execute across the padding, but it's done with
  297. dnl  nop's so it'll work.
  298. define(ALIGN_OFFSET,
  299. m4_assert_numargs(2)
  300. `ALIGN($1)
  301. forloop(`i',1,$2,` nop
  302. ')')
  303. dnl  Usage: defframe(name,offset)
  304. dnl
  305. dnl  Make a definition like the following with which to access a parameter
  306. dnl  or variable on the stack.
  307. dnl
  308. dnl         define(name,`FRAME+offset(%esp)')
  309. dnl
  310. dnl  Actually m4_empty_if_zero(FRAME+offset) is used, which will save one
  311. dnl  byte if FRAME+offset is zero, by putting (%esp) rather than 0(%esp).
  312. dnl  Use define(`defframe_empty_if_zero_disabled',1) if for some reason the
  313. dnl  zero offset is wanted.
  314. dnl
  315. dnl  The new macro also gets a check that when it's used FRAME is actually
  316. dnl  defined, and that the final %esp offset isn't negative, which would
  317. dnl  mean an attempt to access something below the current %esp.
  318. dnl
  319. dnl  deflit() is used rather than a plain define(), so the new macro won't
  320. dnl  delete any following parenthesized expression.  name(%edi) will come
  321. dnl  out say as 16(%esp)(%edi).  This isn't valid assembler and should
  322. dnl  provoke an error, which is better than silently giving just 16(%esp).
  323. dnl
  324. dnl  See README for more on the suggested way to access the stack frame.
  325. define(defframe,
  326. m4_assert_numargs(2)
  327. `deflit(`$1',
  328. m4_assert_defined(`FRAME')
  329. `defframe_check_notbelow(`$1',$2,FRAME)dnl
  330. defframe_empty_if_zero(FRAME+($2))(%esp)')')
  331. dnl  Called: defframe_empty_if_zero(expression)
  332. define(defframe_empty_if_zero,
  333. m4_assert_numargs(1)
  334. `ifelse(defframe_empty_if_zero_disabled,1,
  335. `eval($1)',
  336. `m4_empty_if_zero($1)')')
  337. dnl  Called: defframe_check_notbelow(`name',offset,FRAME)
  338. define(defframe_check_notbelow,
  339. m4_assert_numargs(3)
  340. `ifelse(eval(($3)+($2)<0),1,
  341. `m4_error(`$1 at frame offset $2 used when FRAME is only $3 bytes
  342. ')')')
  343. dnl  Usage: FRAME_pushl()
  344. dnl         FRAME_popl()
  345. dnl         FRAME_addl_esp(n)
  346. dnl         FRAME_subl_esp(n)
  347. dnl
  348. dnl  Adjust FRAME appropriately for a pushl or popl, or for an addl or subl
  349. dnl  %esp of n bytes.
  350. dnl
  351. dnl  Using these macros is completely optional.  Sometimes it makes more
  352. dnl  sense to put explicit deflit(`FRAME',N) forms, especially when there's
  353. dnl  jumps and different sequences of FRAME values need to be used in
  354. dnl  different places.
  355. define(FRAME_pushl,
  356. m4_assert_numargs(0)
  357. m4_assert_defined(`FRAME')
  358. `deflit(`FRAME',eval(FRAME+4))')
  359. define(FRAME_popl,
  360. m4_assert_numargs(0)
  361. m4_assert_defined(`FRAME')
  362. `deflit(`FRAME',eval(FRAME-4))')
  363. define(FRAME_addl_esp,
  364. m4_assert_numargs(1)
  365. m4_assert_defined(`FRAME')
  366. `deflit(`FRAME',eval(FRAME-($1)))')
  367. define(FRAME_subl_esp,
  368. m4_assert_numargs(1)
  369. m4_assert_defined(`FRAME')
  370. `deflit(`FRAME',eval(FRAME+($1)))')
  371. dnl  Usage: defframe_pushl(name)
  372. dnl
  373. dnl  Do a combination FRAME_pushl() and a defframe() to name the stack
  374. dnl  location just pushed.  This should come after a pushl instruction.
  375. dnl  Putting it on the same line works and avoids lengthening the code.  For
  376. dnl  example,
  377. dnl
  378. dnl         pushl   %eax     defframe_pushl(VAR_COUNTER)
  379. dnl
  380. dnl  Notice the defframe() is done with an unquoted -FRAME thus giving its
  381. dnl  current value without tracking future changes.
  382. define(defframe_pushl,
  383. m4_assert_numargs(1)
  384. `FRAME_pushl()defframe(`$1',-FRAME)')
  385. dnl  --------------------------------------------------------------------------
  386. dnl  Assembler instruction macros.
  387. dnl
  388. dnl  Usage: emms_or_femms
  389. dnl         femms_available_p
  390. dnl
  391. dnl  femms_available_p expands to 1 or 0 according to whether the AMD 3DNow
  392. dnl  femms instruction is available.  emms_or_femms expands to femms if
  393. dnl  available, or emms if not.
  394. dnl
  395. dnl  emms_or_femms is meant for use in the K6 directory where plain K6
  396. dnl  (without femms) and K6-2 and K6-3 (with a slightly faster femms) are
  397. dnl  supported together.
  398. dnl
  399. dnl  On K7 femms is no longer faster and is just an alias for emms, so plain
  400. dnl  emms may as well be used.
  401. define(femms_available_p,
  402. m4_assert_numargs(-1)
  403. `m4_ifdef_anyof_p(
  404. `HAVE_HOST_CPU_k62',
  405. `HAVE_HOST_CPU_k63',
  406. `HAVE_HOST_CPU_athlon')')
  407. define(emms_or_femms,
  408. m4_assert_numargs(-1)
  409. `ifelse(femms_available_p,1,`femms',`emms')')
  410. dnl  Usage: femms
  411. dnl
  412. dnl  Gas 2.9.1 which comes with FreeBSD 3.4 doesn't support femms, so the
  413. dnl  following is a replacement using .byte.
  414. define(femms,
  415. m4_assert_numargs(-1)
  416. `.byte 15,14 C AMD 3DNow femms')
  417. dnl  Usage: jadcl0(op)
  418. dnl
  419. dnl  Generate a jnc/incl as a substitute for adcl $0,op.  Note this isn't an
  420. dnl  exact replacement, since it doesn't set the flags like adcl does.
  421. dnl
  422. dnl  This finds a use in K6 mpn_addmul_1, mpn_submul_1, mpn_mul_basecase and
  423. dnl  mpn_sqr_basecase because on K6 an adcl is slow, the branch
  424. dnl  misprediction penalty is small, and the multiply algorithm used leads
  425. dnl  to a carry bit on average only 1/4 of the time.
  426. dnl
  427. dnl  jadcl0_disabled can be set to 1 to instead generate an ordinary adcl
  428. dnl  for comparison.  For example,
  429. dnl
  430. dnl define(`jadcl0_disabled',1)
  431. dnl
  432. dnl  When using a register operand, eg. "jadcl0(%edx)", the jnc/incl code is
  433. dnl  the same size as an adcl.  This makes it possible to use the exact same
  434. dnl  computed jump code when testing the relative speed of the two.
  435. define(jadcl0,
  436. m4_assert_numargs(1)
  437. `ifelse(jadcl0_disabled,1,
  438. `adcl $`'0, $1',
  439. `jnc L(jadcl0_`'jadcl0_counter)
  440. incl $1
  441. L(jadcl0_`'jadcl0_counter):
  442. define(`jadcl0_counter',incr(jadcl0_counter))')')
  443. define(jadcl0_counter,1)
  444. dnl  Usage: x86_lookup(target, key,value, key,value, ...)
  445. dnl         x86_lookup_p(target, key,value, key,value, ...)
  446. dnl
  447. dnl  Look for `target' among the `key' parameters.
  448. dnl
  449. dnl  x86_lookup expands to the corresponding `value', or generates an error
  450. dnl  if `target' isn't found.
  451. dnl
  452. dnl  x86_lookup_p expands to 1 if `target' is found, or 0 if not.
  453. define(x86_lookup,
  454. m4_assert_numargs_range(1,999)
  455. `ifelse(eval($#<3),1,
  456. `m4_error(`unrecognised part of x86 instruction: $1
  457. ')',
  458. `ifelse(`$1',`$2', `$3',
  459. `x86_lookup(`$1',shift(shift(shift($@))))')')')
  460. define(x86_lookup_p,
  461. m4_assert_numargs_range(1,999)
  462. `ifelse(eval($#<3),1, `0',
  463. `ifelse(`$1',`$2',    `1',
  464. `x86_lookup_p(`$1',shift(shift(shift($@))))')')')
  465. dnl  Usage: x86_opcode_reg32(reg)
  466. dnl         x86_opcode_reg32_p(reg)
  467. dnl
  468. dnl  x86_opcode_reg32 expands to the standard 3 bit encoding for the given
  469. dnl  32-bit register, eg. `%ebp' turns into 5.
  470. dnl
  471. dnl  x86_opcode_reg32_p expands to 1 if reg is a valid 32-bit register, or 0
  472. dnl  if not.
  473. define(x86_opcode_reg32,
  474. m4_assert_numargs(1)
  475. `x86_lookup(`$1',x86_opcode_reg32_list)')
  476. define(x86_opcode_reg32_p,
  477. m4_assert_onearg()
  478. `x86_lookup_p(`$1',x86_opcode_reg32_list)')
  479. define(x86_opcode_reg32_list,
  480. ``%eax',0,
  481. `%ecx',1,
  482. `%edx',2,
  483. `%ebx',3,
  484. `%esp',4,
  485. `%ebp',5,
  486. `%esi',6,
  487. `%edi',7')
  488. dnl  Usage: x86_opcode_tttn(cond)
  489. dnl
  490. dnl  Expand to the 4-bit "tttn" field value for the given x86 branch
  491. dnl  condition (like `c', `ae', etc).
  492. define(x86_opcode_tttn,
  493. m4_assert_numargs(1)
  494. `x86_lookup(`$1',x86_opcode_ttn_list)')
  495. define(x86_opcode_tttn_list,
  496. ``o',  0,
  497. `no',  1,
  498. `b',   2, `c',  2, `nae',2,
  499. `nb',  3, `nc', 3, `ae', 3,
  500. `e',   4, `z',  4,
  501. `ne',  5, `nz', 5,
  502. `be',  6, `na', 6,
  503. `nbe', 7, `a',  7,
  504. `s',   8,
  505. `ns',  9,
  506. `p',  10, `pe', 10, `npo',10,
  507. `np', 11, `npe',11, `po', 11,
  508. `l',  12, `nge',12,
  509. `nl', 13, `ge', 13,
  510. `le', 14, `ng', 14,
  511. `nle',15, `g',  15')
  512. dnl  Usage: cmovCC(%srcreg,%dstreg)
  513. dnl
  514. dnl  Emit a cmov instruction, using a .byte sequence, since various past
  515. dnl  versions of gas don't know cmov.  For example,
  516. dnl
  517. dnl         cmovz(  %eax, %ebx)
  518. dnl
  519. dnl  The source operand can only be a plain register.  (m4 code implementing
  520. dnl  full memory addressing modes exists, believe it or not, but isn't
  521. dnl  currently needed and isn't included.)
  522. dnl
  523. dnl  All the standard conditions are defined.  Attempting to use one without
  524. dnl  the macro parentheses, such as just "cmovbe %eax, %ebx", will provoke
  525. dnl  an error.  This protects against writing something old gas wouldn't
  526. dnl  understand.
  527. dnl  Called: define_cmov_many(cond,tttn,cond,tttn,...)
  528. define(define_cmov_many,
  529. `ifelse(m4_length(`$1'),0,,
  530. `define_cmov(`$1',`$2')define_cmov_many(shift(shift($@)))')')
  531. dnl  Called: define_cmov(cond,tttn)
  532. dnl  Emit basically define(cmov<cond>,`cmov_internal(<cond>,<ttn>,`$1',`$2')')
  533. define(define_cmov,
  534. m4_assert_numargs(2)
  535. `define(`cmov$1',
  536. m4_instruction_wrapper()
  537. m4_assert_numargs(2)
  538. `cmov_internal'(m4_doublequote($`'0),``$2'',dnl
  539. m4_doublequote($`'1),m4_doublequote($`'2)))')
  540. define_cmov_many(x86_opcode_tttn_list)
  541. dnl  Called: cmov_internal(name,tttn,src,dst)
  542. define(cmov_internal,
  543. m4_assert_numargs(4)
  544. `.byte dnl
  545. 15, dnl
  546. eval(64+$2), dnl
  547. eval(192+8*x86_opcode_reg32(`$4')+x86_opcode_reg32(`$3')) dnl
  548. C `$1 $3, $4'')
  549. dnl  Usage: x86_opcode_regmmx(reg)
  550. dnl
  551. dnl  Validate the given mmx register, and return its number, 0 to 7.
  552. define(x86_opcode_regmmx,
  553. m4_assert_numargs(1)
  554. `x86_lookup(`$1',x86_opcode_regmmx_list)')
  555. define(x86_opcode_regmmx_list,
  556. ``%mm0',0,
  557. `%mm1',1,
  558. `%mm2',2,
  559. `%mm3',3,
  560. `%mm4',4,
  561. `%mm5',5,
  562. `%mm6',6,
  563. `%mm7',7')
  564. dnl  Usage: psadbw(%srcreg,%dstreg)
  565. dnl
  566. dnl  Oldish versions of gas don't know psadbw, in particular gas 2.9.1 on
  567. dnl  FreeBSD 3.3 and 3.4 doesn't, so instead emit .byte sequences.  For
  568. dnl  example,
  569. dnl
  570. dnl         psadbw( %mm1, %mm2)
  571. dnl
  572. dnl  Only register->register forms are supported here, which suffices for
  573. dnl  the current code.
  574. define(psadbw,
  575. m4_instruction_wrapper()
  576. m4_assert_numargs(2)
  577. `.byte 0x0f,0xf6,dnl
  578. eval(192+x86_opcode_regmmx(`$2')*8+x86_opcode_regmmx(`$1')) dnl
  579. C `psadbw $1, $2'')
  580. dnl  Usage: Zdisp(inst,op,op,op)
  581. dnl
  582. dnl  Generate explicit .byte sequences if necessary to force a byte-sized
  583. dnl  zero displacement on an instruction.  For example,
  584. dnl
  585. dnl         Zdisp(  movl,   0,(%esi), %eax)
  586. dnl
  587. dnl  expands to
  588. dnl
  589. dnl                 .byte   139,70,0  C movl 0(%esi), %eax
  590. dnl
  591. dnl  If the displacement given isn't 0, then normal assembler code is
  592. dnl  generated.  For example,
  593. dnl
  594. dnl         Zdisp(  movl,   4,(%esi), %eax)
  595. dnl
  596. dnl  expands to
  597. dnl
  598. dnl                 movl    4(%esi), %eax
  599. dnl
  600. dnl  This means a single Zdisp() form can be used with an expression for the
  601. dnl  displacement, and .byte will be used only if necessary.  The
  602. dnl  displacement argument is eval()ed.
  603. dnl
  604. dnl  Because there aren't many places a 0(reg) form is wanted, Zdisp is
  605. dnl  implemented with a table of instructions and encodings.  A new entry is
  606. dnl  needed for any different operation or registers.  The table is split
  607. dnl  into separate macros to avoid overflowing BSD m4 macro expansion space.
  608. define(Zdisp,
  609. m4_assert_numargs(4)
  610. `define(`Zdisp_found',0)dnl
  611. Zdisp_1($@)dnl
  612. Zdisp_2($@)dnl
  613. Zdisp_3($@)dnl
  614. Zdisp_4($@)dnl
  615. ifelse(Zdisp_found,0,
  616. `m4_error(`unrecognised instruction in Zdisp: $1 $2 $3 $4
  617. ')')')
  618. define(Zdisp_1,`dnl
  619. Zdisp_match( adcl, 0,(%edx), %eax,        `0x13,0x42,0x00',           $@)`'dnl
  620. Zdisp_match( adcl, 0,(%edx), %ebx,        `0x13,0x5a,0x00',           $@)`'dnl
  621. Zdisp_match( adcl, 0,(%edx), %esi,        `0x13,0x72,0x00',           $@)`'dnl
  622. Zdisp_match( addl, %ebx, 0,(%edi),        `0x01,0x5f,0x00',           $@)`'dnl
  623. Zdisp_match( addl, %ecx, 0,(%edi),        `0x01,0x4f,0x00',           $@)`'dnl
  624. Zdisp_match( addl, %esi, 0,(%edi),        `0x01,0x77,0x00',           $@)`'dnl
  625. Zdisp_match( sbbl, 0,(%edx), %eax,        `0x1b,0x42,0x00',           $@)`'dnl
  626. Zdisp_match( sbbl, 0,(%edx), %esi,        `0x1b,0x72,0x00',           $@)`'dnl
  627. Zdisp_match( subl, %ecx, 0,(%edi),        `0x29,0x4f,0x00',           $@)`'dnl
  628. Zdisp_match( movzbl, 0,(%eax,%ebp), %eax, `0x0f,0xb6,0x44,0x28,0x00', $@)`'dnl
  629. Zdisp_match( movzbl, 0,(%ecx,%edi), %edi, `0x0f,0xb6,0x7c,0x39,0x00', $@)`'dnl
  630. Zdisp_match( adc, 0,(%ebx,%ecx,4), %eax,  `0x13,0x44,0x8b,0x00',      $@)`'dnl
  631. Zdisp_match( sbb, 0,(%ebx,%ecx,4), %eax,  `0x1b,0x44,0x8b,0x00',      $@)`'dnl
  632. ')
  633. define(Zdisp_2,`dnl
  634. Zdisp_match( movl, %eax, 0,(%edi),        `0x89,0x47,0x00',           $@)`'dnl
  635. Zdisp_match( movl, %ebx, 0,(%edi),        `0x89,0x5f,0x00',           $@)`'dnl
  636. Zdisp_match( movl, %esi, 0,(%edi),        `0x89,0x77,0x00',           $@)`'dnl
  637. Zdisp_match( movl, 0,(%ebx), %eax,        `0x8b,0x43,0x00',           $@)`'dnl
  638. Zdisp_match( movl, 0,(%ebx), %esi,        `0x8b,0x73,0x00',           $@)`'dnl
  639. Zdisp_match( movl, 0,(%edx), %eax,        `0x8b,0x42,0x00',           $@)`'dnl
  640. Zdisp_match( movl, 0,(%esi), %eax,        `0x8b,0x46,0x00',           $@)`'dnl
  641. Zdisp_match( movl, 0,(%esi,%ecx,4), %eax, `0x8b,0x44,0x8e,0x00',      $@)`'dnl
  642. Zdisp_match( mov, 0,(%esi,%ecx,4), %eax,  `0x8b,0x44,0x8e,0x00',      $@)`'dnl
  643. Zdisp_match( mov, %eax, 0,(%edi,%ecx,4),  `0x89,0x44,0x8f,0x00',      $@)`'dnl
  644. ')
  645. define(Zdisp_3,`dnl
  646. Zdisp_match( movq, 0,(%eax,%ecx,8), %mm0, `0x0f,0x6f,0x44,0xc8,0x00', $@)`'dnl
  647. Zdisp_match( movq, 0,(%ebx,%eax,4), %mm0, `0x0f,0x6f,0x44,0x83,0x00', $@)`'dnl
  648. Zdisp_match( movq, 0,(%ebx,%eax,4), %mm2, `0x0f,0x6f,0x54,0x83,0x00', $@)`'dnl
  649. Zdisp_match( movq, 0,(%ebx,%ecx,4), %mm0, `0x0f,0x6f,0x44,0x8b,0x00', $@)`'dnl
  650. Zdisp_match( movq, 0,(%edx), %mm0,        `0x0f,0x6f,0x42,0x00',      $@)`'dnl
  651. Zdisp_match( movq, 0,(%esi), %mm0,        `0x0f,0x6f,0x46,0x00',      $@)`'dnl
  652. Zdisp_match( movq, %mm0, 0,(%edi),        `0x0f,0x7f,0x47,0x00',      $@)`'dnl
  653. Zdisp_match( movq, %mm2, 0,(%ecx,%eax,4), `0x0f,0x7f,0x54,0x81,0x00', $@)`'dnl
  654. Zdisp_match( movq, %mm2, 0,(%edx,%eax,4), `0x0f,0x7f,0x54,0x82,0x00', $@)`'dnl
  655. Zdisp_match( movq, %mm0, 0,(%edx,%ecx,8), `0x0f,0x7f,0x44,0xca,0x00', $@)`'dnl
  656. ')
  657. define(Zdisp_4,`dnl
  658. Zdisp_match( movd, 0,(%eax,%ecx,4), %mm0, `0x0f,0x6e,0x44,0x88,0x00', $@)`'dnl
  659. Zdisp_match( movd, 0,(%eax,%ecx,8), %mm1, `0x0f,0x6e,0x4c,0xc8,0x00', $@)`'dnl
  660. Zdisp_match( movd, 0,(%edx,%ecx,8), %mm0, `0x0f,0x6e,0x44,0xca,0x00', $@)`'dnl
  661. Zdisp_match( movd, %mm0, 0,(%eax,%ecx,4), `0x0f,0x7e,0x44,0x88,0x00', $@)`'dnl
  662. Zdisp_match( movd, %mm0, 0,(%ecx,%eax,4), `0x0f,0x7e,0x44,0x81,0x00', $@)`'dnl
  663. Zdisp_match( movd, %mm2, 0,(%ecx,%eax,4), `0x0f,0x7e,0x54,0x81,0x00', $@)`'dnl
  664. Zdisp_match( movd, %mm0, 0,(%edx,%ecx,4), `0x0f,0x7e,0x44,0x8a,0x00', $@)`'dnl
  665. ')
  666. define(Zdisp_match,
  667. m4_assert_numargs(9)
  668. `ifelse(eval(m4_stringequal_p(`$1',`$6')
  669. && m4_stringequal_p(`$2',0)
  670. && m4_stringequal_p(`$3',`$8')
  671. && m4_stringequal_p(`$4',`$9')),1,
  672. `define(`Zdisp_found',1)dnl
  673. ifelse(eval(`$7'),0,
  674. ` .byte $5  C `$1 0$3, $4'',
  675. ` $6 $7$8, $9')',
  676. `ifelse(eval(m4_stringequal_p(`$1',`$6')
  677. && m4_stringequal_p(`$2',`$7')
  678. && m4_stringequal_p(`$3',0)
  679. && m4_stringequal_p(`$4',`$9')),1,
  680. `define(`Zdisp_found',1)dnl
  681. ifelse(eval(`$8'),0,
  682. ` .byte $5  C `$1 $2, 0$4'',
  683. ` $6 $7, $8$9')')')')
  684. dnl  Usage: shldl(count,src,dst)
  685. dnl         shrdl(count,src,dst)
  686. dnl         shldw(count,src,dst)
  687. dnl         shrdw(count,src,dst)
  688. dnl
  689. dnl  Generate a double-shift instruction, possibly omitting a %cl count
  690. dnl  parameter if that's what the assembler requires, as indicated by
  691. dnl  WANT_SHLDL_CL in config.m4.  For example,
  692. dnl
  693. dnl         shldl(  %cl, %eax, %ebx)
  694. dnl
  695. dnl  turns into either
  696. dnl
  697. dnl         shldl   %cl, %eax, %ebx
  698. dnl  or
  699. dnl         shldl   %eax, %ebx
  700. dnl
  701. dnl  Immediate counts are always passed through unchanged.  For example,
  702. dnl
  703. dnl         shrdl(  $2, %esi, %edi)
  704. dnl  becomes
  705. dnl         shrdl   $2, %esi, %edi
  706. dnl
  707. dnl
  708. dnl  If you forget to use the macro form "shldl( ...)" and instead write
  709. dnl  just a plain "shldl ...", an error results.  This ensures the necessary
  710. dnl  variant treatment of %cl isn't accidentally bypassed.
  711. define(define_shd_instruction,
  712. m4_assert_numargs(1)
  713. `define($1,
  714. m4_instruction_wrapper()
  715. m4_assert_numargs(3)
  716. `shd_instruction'(m4_doublequote($`'0),m4_doublequote($`'1),dnl
  717. m4_doublequote($`'2),m4_doublequote($`'3)))')
  718. dnl  Effectively: define(shldl,`shd_instruction(`$0',`$1',`$2',`$3')') etc
  719. define_shd_instruction(shldl)
  720. define_shd_instruction(shrdl)
  721. define_shd_instruction(shldw)
  722. define_shd_instruction(shrdw)
  723. dnl  Called: shd_instruction(op,count,src,dst)
  724. define(shd_instruction,
  725. m4_assert_numargs(4)
  726. m4_assert_defined(`WANT_SHLDL_CL')
  727. `ifelse(eval(m4_stringequal_p(`$2',`%cl') && !WANT_SHLDL_CL),1,
  728. ``$1' `$3', `$4'',
  729. ``$1' `$2', `$3', `$4'')')
  730. dnl  Usage: ASSERT([cond][,instructions])
  731. dnl
  732. dnl  If WANT_ASSERT is 1, output the given instructions and expect the given
  733. dnl  flags condition to then be satisfied.  For example,
  734. dnl
  735. dnl         ASSERT(ne, `cmpl %eax, %ebx')
  736. dnl
  737. dnl  The instructions can be omitted to just assert a flags condition with
  738. dnl  no extra calculation.  For example,
  739. dnl
  740. dnl         ASSERT(nc)
  741. dnl
  742. dnl  When `instructions' is not empty, a pushf/popf is added to preserve the
  743. dnl  flags, but the instructions themselves must preserve any registers that
  744. dnl  matter.  FRAME is adjusted for the push and pop, so the instructions
  745. dnl  given can use defframe() stack variables.
  746. dnl
  747. dnl  The condition can be omitted to just output the given instructions when
  748. dnl  assertion checking is wanted.  In this case the pushf/popf is omitted.
  749. dnl  For example,
  750. dnl
  751. dnl         ASSERT(, `movl %eax, VAR_KEEPVAL')
  752. define(ASSERT,
  753. m4_assert_numargs_range(1,2)
  754. m4_assert_defined(`WANT_ASSERT')
  755. `ifelse(WANT_ASSERT,1,
  756. `ifelse(`$1',,
  757. `$2',
  758. `C ASSERT
  759. ifelse(`$2',,,` pushf ifdef(`FRAME',`FRAME_pushl()')')
  760. $2
  761. j`$1' L(ASSERT_ok`'ASSERT_counter)
  762. ud2 C assertion failed
  763. L(ASSERT_ok`'ASSERT_counter):
  764. ifelse(`$2',,,` popf ifdef(`FRAME',`FRAME_popl()')')
  765. define(`ASSERT_counter',incr(ASSERT_counter))')')')
  766. define(ASSERT_counter,1)
  767. dnl  Usage: movl_text_address(label,register)
  768. dnl
  769. dnl  Get the address of a text segment label, using either a plain movl or a
  770. dnl  position-independent calculation, as necessary.  For example,
  771. dnl
  772. dnl         movl_code_address(L(foo),%eax)
  773. dnl
  774. dnl  This macro is only meant for use in ASSERT()s or when testing, since
  775. dnl  the PIC sequence it generates will want to be done with a ret balancing
  776. dnl  the call on CPUs with return address branch prediction.
  777. dnl
  778. dnl  The addl generated here has a backward reference to the label, and so
  779. dnl  won't suffer from the two forwards references bug in old gas (described
  780. dnl  in mpn/x86/README).
  781. define(movl_text_address,
  782. m4_assert_numargs(2)
  783. `ifdef(`PIC',
  784. `call L(movl_text_address_`'movl_text_address_counter)
  785. L(movl_text_address_`'movl_text_address_counter):
  786. popl $2 C %eip
  787. addl `$'$1-L(movl_text_address_`'movl_text_address_counter), $2
  788. define(`movl_text_address_counter',incr(movl_text_address_counter))',
  789. `movl `$'$1, $2')')
  790. define(movl_text_address_counter,1)
  791. dnl  Usage: notl_or_xorl_GMP_NUMB_MASK(reg)
  792. dnl
  793. dnl  Expand to either "notl `reg'" or "xorl $GMP_NUMB_BITS,`reg'" as
  794. dnl  appropriate for nails in use or not.
  795. define(notl_or_xorl_GMP_NUMB_MASK,
  796. m4_assert_numargs(1)
  797. `ifelse(GMP_NAIL_BITS,0,
  798. `notl `$1'',
  799. `xorl $GMP_NUMB_MASK, `$1'')')
  800. dnl  Usage LEA(symbol,reg)
  801. define(`LEA',`
  802. define(`EPILOGUE_cpu',
  803. `
  804. L(movl_eip_`'substr($2,1)):
  805. movl (%esp), $2
  806. ret_internal
  807. SIZE($'`1, .-$'`1)')
  808.         call    L(movl_eip_`'substr($2,1))
  809.         addl    $_GLOBAL_OFFSET_TABLE_, $2
  810.         movl    $1@GOT($2), $2
  811. ')
  812. define(`DEF_OBJECT',
  813. m4_assert_numargs_range(1,2)
  814. `RODATA
  815. ALIGN(ifelse($#,1,2,$2))
  816. $1:
  817. ')
  818. define(`END_OBJECT',
  819. m4_assert_numargs(1)
  820. ` SIZE(`$1',.-`$1')')
  821. divert`'dnl