PLearn 0.1
Classes | Defines | Functions
sse.h File Reference

Go to the source code of this file.

Classes

union  __attribute__

Defines

#define sse_i2r(op, imm, reg)
#define sse_m2r(op, mem, reg)
#define sse_r2m(op, reg, mem)
#define sse_r2r(op, regs, regd)   __asm__ __volatile__ (#op " %" #regs ", %" #regd)
#define sse_r2ri(op, regs, regd, imm)
#define sse_m2m(op, mems, memd, xmmreg)
#define sse_m2ri(op, mem, reg, subop)
#define sse_m2mi(op, mems, memd, xmmreg, subop)
#define movaps_m2r(var, reg)   sse_m2r(movaps, var, reg)
#define movaps_r2m(reg, var)   sse_r2m(movaps, reg, var)
#define movaps_r2r(regs, regd)   sse_r2r(movaps, regs, regd)
#define movaps(vars, vard)
#define movntps_r2m(xmmreg, var)   sse_r2m(movntps, xmmreg, var)
#define movntq_r2m(mmreg, var)   sse_r2m(movntq, mmreg, var)
#define movups_m2r(var, reg)   sse_m2r(movups, var, reg)
#define movups_r2m(reg, var)   sse_r2m(movups, reg, var)
#define movups_r2r(regs, regd)   sse_r2r(movups, regs, regd)
#define movups(vars, vard)
#define movhlps_r2r(regs, regd)   sse_r2r(movhlps, regs, regd)
#define movlhps_r2r(regs, regd)   sse_r2r(movlhps, regs, regd)
#define movhps_m2r(var, reg)   sse_m2r(movhps, var, reg)
#define movhps_r2m(reg, var)   sse_r2m(movhps, reg, var)
#define movhps(vars, vard)
#define movlps_m2r(var, reg)   sse_m2r(movlps, var, reg)
#define movlps_r2m(reg, var)   sse_r2m(movlps, reg, var)
#define movlps(vars, vard)
#define movss_m2r(var, reg)   sse_m2r(movss, var, reg)
#define movss_r2m(reg, var)   sse_r2m(movss, reg, var)
#define movss_r2r(regs, regd)   sse_r2r(movss, regs, regd)
#define movss(vars, vard)
#define pshufw_m2r(var, reg, index)   sse_m2ri(pshufw, var, reg, index)
#define pshufw_r2r(regs, regd, index)   sse_r2ri(pshufw, regs, regd, index)
#define shufps_m2r(var, reg, index)   sse_m2ri(shufps, var, reg, index)
#define shufps_r2r(regs, regd, index)   sse_r2ri(shufps, regs, regd, index)
#define cvtpi2ps_m2r(var, xmmreg)   sse_m2r(cvtpi2ps, var, xmmreg)
#define cvtpi2ps_r2r(mmreg, xmmreg)   sse_r2r(cvtpi2ps, mmreg, xmmreg)
#define cvtps2pi_m2r(var, mmreg)   sse_m2r(cvtps2pi, var, mmreg)
#define cvtps2pi_r2r(xmmreg, mmreg)   sse_r2r(cvtps2pi, mmreg, xmmreg)
#define cvttps2pi_m2r(var, mmreg)   sse_m2r(cvttps2pi, var, mmreg)
#define cvttps2pi_r2r(xmmreg, mmreg)   sse_r2r(cvttps2pi, mmreg, xmmreg)
#define cvtsi2ss_m2r(var, xmmreg)   sse_m2r(cvtsi2ss, var, xmmreg)
#define cvtsi2ss_r2r(reg, xmmreg)   sse_r2r(cvtsi2ss, reg, xmmreg)
#define cvtss2si_m2r(var, reg)   sse_m2r(cvtss2si, var, reg)
#define cvtss2si_r2r(xmmreg, reg)   sse_r2r(cvtss2si, xmmreg, reg)
#define cvttss2si_m2r(var, reg)   sse_m2r(cvtss2si, var, reg)
#define cvttss2si_r2r(xmmreg, reg)   sse_r2r(cvtss2si, xmmreg, reg)
#define pextrw_r2r(mmreg, reg, field)   sse_r2ri(pextrw, mmreg, reg, field)
#define pinsrw_r2r(reg, mmreg, field)   sse_r2ri(pinsrw, reg, mmreg, field)
#define movmskps(xmmreg, reg)   __asm__ __volatile__ ("movmskps %" #xmmreg ", %" #reg)
#define pmovmskb(mmreg, reg)   __asm__ __volatile__ ("movmskps %" #mmreg ", %" #reg)
#define maskmovq(mmregs, fieldreg)   sse_r2ri(maskmovq, mmregs, fieldreg)
#define addps_m2r(var, reg)   sse_m2r(addps, var, reg)
#define addps_r2r(regs, regd)   sse_r2r(addps, regs, regd)
#define addps(vars, vard, xmmreg)   sse_m2m(addps, vars, vard, xmmreg)
#define addss_m2r(var, reg)   sse_m2r(addss, var, reg)
#define addss_r2r(regs, regd)   sse_r2r(addss, regs, regd)
#define addss(vars, vard, xmmreg)   sse_m2m(addss, vars, vard, xmmreg)
#define subps_m2r(var, reg)   sse_m2r(subps, var, reg)
#define subps_r2r(regs, regd)   sse_r2r(subps, regs, regd)
#define subps(vars, vard, xmmreg)   sse_m2m(subps, vars, vard, xmmreg)
#define subss_m2r(var, reg)   sse_m2r(subss, var, reg)
#define subss_r2r(regs, regd)   sse_r2r(subss, regs, regd)
#define subss(vars, vard, xmmreg)   sse_m2m(subss, vars, vard, xmmreg)
#define psadbw_m2r(var, reg)   sse_m2r(psadbw, var, reg)
#define psadbw_r2r(regs, regd)   sse_r2r(psadbw, regs, regd)
#define psadbw(vars, vard, mmreg)   sse_m2m(psadbw, vars, vard, mmreg)
#define pmulhuw_m2r(var, reg)   sse_m2r(pmulhuw, var, reg)
#define pmulhuw_r2r(regs, regd)   sse_r2r(pmulhuw, regs, regd)
#define pmulhuw(vars, vard, mmreg)   sse_m2m(pmulhuw, vars, vard, mmreg)
#define mulps_m2r(var, reg)   sse_m2r(mulps, var, reg)
#define mulps_r2r(regs, regd)   sse_r2r(mulps, regs, regd)
#define mulps(vars, vard, xmmreg)   sse_m2m(mulps, vars, vard, xmmreg)
#define mulss_m2r(var, reg)   sse_m2r(mulss, var, reg)
#define mulss_r2r(regs, regd)   sse_r2r(mulss, regs, regd)
#define mulss(vars, vard, xmmreg)   sse_m2m(mulss, vars, vard, xmmreg)
#define divps_m2r(var, reg)   sse_m2r(divps, var, reg)
#define divps_r2r(regs, regd)   sse_r2r(divps, regs, regd)
#define divps(vars, vard, xmmreg)   sse_m2m(divps, vars, vard, xmmreg)
#define divss_m2r(var, reg)   sse_m2r(divss, var, reg)
#define divss_r2r(regs, regd)   sse_r2r(divss, regs, regd)
#define divss(vars, vard, xmmreg)   sse_m2m(divss, vars, vard, xmmreg)
#define rcpps_m2r(var, reg)   sse_m2r(rcpps, var, reg)
#define rcpps_r2r(regs, regd)   sse_r2r(rcpps, regs, regd)
#define rcpps(vars, vard, xmmreg)   sse_m2m(rcpps, vars, vard, xmmreg)
#define rcpss_m2r(var, reg)   sse_m2r(rcpss, var, reg)
#define rcpss_r2r(regs, regd)   sse_r2r(rcpss, regs, regd)
#define rcpss(vars, vard, xmmreg)   sse_m2m(rcpss, vars, vard, xmmreg)
#define rsqrtps_m2r(var, reg)   sse_m2r(rsqrtps, var, reg)
#define rsqrtps_r2r(regs, regd)   sse_r2r(rsqrtps, regs, regd)
#define rsqrtps(vars, vard, xmmreg)   sse_m2m(rsqrtps, vars, vard, xmmreg)
#define rsqrtss_m2r(var, reg)   sse_m2r(rsqrtss, var, reg)
#define rsqrtss_r2r(regs, regd)   sse_r2r(rsqrtss, regs, regd)
#define rsqrtss(vars, vard, xmmreg)   sse_m2m(rsqrtss, vars, vard, xmmreg)
#define sqrtps_m2r(var, reg)   sse_m2r(sqrtps, var, reg)
#define sqrtps_r2r(regs, regd)   sse_r2r(sqrtps, regs, regd)
#define sqrtps(vars, vard, xmmreg)   sse_m2m(sqrtps, vars, vard, xmmreg)
#define sqrtss_m2r(var, reg)   sse_m2r(sqrtss, var, reg)
#define sqrtss_r2r(regs, regd)   sse_r2r(sqrtss, regs, regd)
#define sqrtss(vars, vard, xmmreg)   sse_m2m(sqrtss, vars, vard, xmmreg)
#define pavgb_m2r(var, reg)   sse_m2r(pavgb, var, reg)
#define pavgb_r2r(regs, regd)   sse_r2r(pavgb, regs, regd)
#define pavgb(vars, vard, mmreg)   sse_m2m(pavgb, vars, vard, mmreg)
#define pavgw_m2r(var, reg)   sse_m2r(pavgw, var, reg)
#define pavgw_r2r(regs, regd)   sse_r2r(pavgw, regs, regd)
#define pavgw(vars, vard, mmreg)   sse_m2m(pavgw, vars, vard, mmreg)
#define andps_m2r(var, reg)   sse_m2r(andps, var, reg)
#define andps_r2r(regs, regd)   sse_r2r(andps, regs, regd)
#define andps(vars, vard, xmmreg)   sse_m2m(andps, vars, vard, xmmreg)
#define andnps_m2r(var, reg)   sse_m2r(andnps, var, reg)
#define andnps_r2r(regs, regd)   sse_r2r(andnps, regs, regd)
#define andnps(vars, vard, xmmreg)   sse_m2m(andnps, vars, vard, xmmreg)
#define orps_m2r(var, reg)   sse_m2r(orps, var, reg)
#define orps_r2r(regs, regd)   sse_r2r(orps, regs, regd)
#define orps(vars, vard, xmmreg)   sse_m2m(orps, vars, vard, xmmreg)
#define xorps_m2r(var, reg)   sse_m2r(xorps, var, reg)
#define xorps_r2r(regs, regd)   sse_r2r(xorps, regs, regd)
#define xorps(vars, vard, xmmreg)   sse_m2m(xorps, vars, vard, xmmreg)
#define pmaxub_m2r(var, reg)   sse_m2r(pmaxub, var, reg)
#define pmaxub_r2r(regs, regd)   sse_r2r(pmaxub, regs, regd)
#define pmaxub(vars, vard, mmreg)   sse_m2m(pmaxub, vars, vard, mmreg)
#define pmaxsw_m2r(var, reg)   sse_m2r(pmaxsw, var, reg)
#define pmaxsw_r2r(regs, regd)   sse_r2r(pmaxsw, regs, regd)
#define pmaxsw(vars, vard, mmreg)   sse_m2m(pmaxsw, vars, vard, mmreg)
#define maxps_m2r(var, reg)   sse_m2r(maxps, var, reg)
#define maxps_r2r(regs, regd)   sse_r2r(maxps, regs, regd)
#define maxps(vars, vard, xmmreg)   sse_m2m(maxps, vars, vard, xmmreg)
#define maxss_m2r(var, reg)   sse_m2r(maxss, var, reg)
#define maxss_r2r(regs, regd)   sse_r2r(maxss, regs, regd)
#define maxss(vars, vard, xmmreg)   sse_m2m(maxss, vars, vard, xmmreg)
#define pminub_m2r(var, reg)   sse_m2r(pminub, var, reg)
#define pminub_r2r(regs, regd)   sse_r2r(pminub, regs, regd)
#define pminub(vars, vard, mmreg)   sse_m2m(pminub, vars, vard, mmreg)
#define pminsw_m2r(var, reg)   sse_m2r(pminsw, var, reg)
#define pminsw_r2r(regs, regd)   sse_r2r(pminsw, regs, regd)
#define pminsw(vars, vard, mmreg)   sse_m2m(pminsw, vars, vard, mmreg)
#define minps_m2r(var, reg)   sse_m2r(minps, var, reg)
#define minps_r2r(regs, regd)   sse_r2r(minps, regs, regd)
#define minps(vars, vard, xmmreg)   sse_m2m(minps, vars, vard, xmmreg)
#define minss_m2r(var, reg)   sse_m2r(minss, var, reg)
#define minss_r2r(regs, regd)   sse_r2r(minss, regs, regd)
#define minss(vars, vard, xmmreg)   sse_m2m(minss, vars, vard, xmmreg)
#define cmpps_m2r(var, reg, op)   sse_m2ri(cmpps, var, reg, op)
#define cmpps_r2r(regs, regd, op)   sse_r2ri(cmpps, regs, regd, op)
#define cmpps(vars, vard, op, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, op)
#define cmpeqps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 0)
#define cmpeqps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 0)
#define cmpeqps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 0)
#define cmpltps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 1)
#define cmpltps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 1)
#define cmpltps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 1)
#define cmpleps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 2)
#define cmpleps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 2)
#define cmpleps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 2)
#define cmpunordps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 3)
#define cmpunordps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 3)
#define cmpunordps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 3)
#define cmpneqps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 4)
#define cmpneqps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 4)
#define cmpneqps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 4)
#define cmpnltps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 5)
#define cmpnltps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 5)
#define cmpnltps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 5)
#define cmpnleps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 6)
#define cmpnleps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 6)
#define cmpnleps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 6)
#define cmpordps_m2r(var, reg)   sse_m2ri(cmpps, var, reg, 7)
#define cmpordps_r2r(regs, regd)   sse_r2ri(cmpps, regs, regd, 7)
#define cmpordps(vars, vard, xmmreg)   sse_m2mi(cmpps, vars, vard, xmmreg, 7)
#define cmpss_m2r(var, reg, op)   sse_m2ri(cmpss, var, reg, op)
#define cmpss_r2r(regs, regd, op)   sse_r2ri(cmpss, regs, regd, op)
#define cmpss(vars, vard, op, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, op)
#define cmpeqss_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 0)
#define cmpeqss_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 0)
#define cmpeqss(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 0)
#define cmpltss_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 1)
#define cmpltss_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 1)
#define cmpltss(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 1)
#define cmpless_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 2)
#define cmpless_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 2)
#define cmpless(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 2)
#define cmpunordss_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 3)
#define cmpunordss_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 3)
#define cmpunordss(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 3)
#define cmpneqss_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 4)
#define cmpneqss_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 4)
#define cmpneqss(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 4)
#define cmpnltss_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 5)
#define cmpnltss_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 5)
#define cmpnltss(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 5)
#define cmpnless_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 6)
#define cmpnless_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 6)
#define cmpnless(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 6)
#define cmpordss_m2r(var, reg)   sse_m2ri(cmpss, var, reg, 7)
#define cmpordss_r2r(regs, regd)   sse_r2ri(cmpss, regs, regd, 7)
#define cmpordss(vars, vard, xmmreg)   sse_m2mi(cmpss, vars, vard, xmmreg, 7)
#define comiss_m2r(var, reg)   sse_m2r(comiss, var, reg)
#define comiss_r2r(regs, regd)   sse_r2r(comiss, regs, regd)
#define comiss(vars, vard, xmmreg)   sse_m2m(comiss, vars, vard, xmmreg)
#define ucomiss_m2r(var, reg)   sse_m2r(ucomiss, var, reg)
#define ucomiss_r2r(regs, regd)   sse_r2r(ucomiss, regs, regd)
#define ucomiss(vars, vard, xmmreg)   sse_m2m(ucomiss, vars, vard, xmmreg)
#define unpcklps_m2r(var, reg)   sse_m2r(unpcklps, var, reg)
#define unpcklps_r2r(regs, regd)   sse_r2r(unpcklps, regs, regd)
#define unpckhps_m2r(var, reg)   sse_m2r(unpckhps, var, reg)
#define unpckhps_r2r(regs, regd)   sse_r2r(unpckhps, regs, regd)
#define fxrstor(mem)
#define fxsave(mem)
#define stmxcsr(mem)
#define ldmxcsr(mem)
#define sfence()   __asm__ __volatile__ ("sfence\n\t")
#define prefetch(mem, hint)
#define prefetcht0(mem)   prefetch(mem, t0)
#define prefetcht1(mem)   prefetch(mem, t1)
#define prefetcht2(mem)   prefetch(mem, t2)
#define prefetchnta(mem)   prefetch(mem, nta)

Functions

int mm_support (void)
int sse_ok (void)

Define Documentation

#define addps (   vars,
  vard,
  xmmreg 
)    sse_m2m(addps, vars, vard, xmmreg)

Definition at line 582 of file sse.h.

#define addps_m2r (   var,
  reg 
)    sse_m2r(addps, var, reg)

Definition at line 580 of file sse.h.

#define addps_r2r (   regs,
  regd 
)    sse_r2r(addps, regs, regd)

Definition at line 581 of file sse.h.

#define addss (   vars,
  vard,
  xmmreg 
)    sse_m2m(addss, vars, vard, xmmreg)

Definition at line 589 of file sse.h.

#define addss_m2r (   var,
  reg 
)    sse_m2r(addss, var, reg)

Definition at line 587 of file sse.h.

#define addss_r2r (   regs,
  regd 
)    sse_r2r(addss, regs, regd)

Definition at line 588 of file sse.h.

#define andnps (   vars,
  vard,
  xmmreg 
)    sse_m2m(andnps, vars, vard, xmmreg)

Definition at line 712 of file sse.h.

#define andnps_m2r (   var,
  reg 
)    sse_m2r(andnps, var, reg)

Definition at line 710 of file sse.h.

#define andnps_r2r (   regs,
  regd 
)    sse_r2r(andnps, regs, regd)

Definition at line 711 of file sse.h.

#define andps (   vars,
  vard,
  xmmreg 
)    sse_m2m(andps, vars, vard, xmmreg)

Definition at line 705 of file sse.h.

#define andps_m2r (   var,
  reg 
)    sse_m2r(andps, var, reg)

Definition at line 703 of file sse.h.

#define andps_r2r (   regs,
  regd 
)    sse_r2r(andps, regs, regd)

Definition at line 704 of file sse.h.

#define cmpeqps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 0)

Definition at line 782 of file sse.h.

#define cmpeqps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 0)

Definition at line 780 of file sse.h.

#define cmpeqps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 0)

Definition at line 781 of file sse.h.

#define cmpeqss (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 0)

Definition at line 822 of file sse.h.

#define cmpeqss_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 0)

Definition at line 820 of file sse.h.

#define cmpeqss_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 0)

Definition at line 821 of file sse.h.

#define cmpleps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 2)

Definition at line 790 of file sse.h.

#define cmpleps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 2)

Definition at line 788 of file sse.h.

#define cmpleps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 2)

Definition at line 789 of file sse.h.

#define cmpless (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 2)

Definition at line 830 of file sse.h.

#define cmpless_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 2)

Definition at line 828 of file sse.h.

#define cmpless_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 2)

Definition at line 829 of file sse.h.

#define cmpltps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 1)

Definition at line 786 of file sse.h.

#define cmpltps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 1)

Definition at line 784 of file sse.h.

#define cmpltps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 1)

Definition at line 785 of file sse.h.

#define cmpltss (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 1)

Definition at line 826 of file sse.h.

#define cmpltss_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 1)

Definition at line 824 of file sse.h.

#define cmpltss_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 1)

Definition at line 825 of file sse.h.

#define cmpneqps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 4)

Definition at line 798 of file sse.h.

#define cmpneqps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 4)

Definition at line 796 of file sse.h.

#define cmpneqps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 4)

Definition at line 797 of file sse.h.

#define cmpneqss (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 4)

Definition at line 838 of file sse.h.

#define cmpneqss_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 4)

Definition at line 836 of file sse.h.

#define cmpneqss_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 4)

Definition at line 837 of file sse.h.

#define cmpnleps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 6)

Definition at line 806 of file sse.h.

#define cmpnleps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 6)

Definition at line 804 of file sse.h.

#define cmpnleps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 6)

Definition at line 805 of file sse.h.

#define cmpnless (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 6)

Definition at line 846 of file sse.h.

#define cmpnless_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 6)

Definition at line 844 of file sse.h.

#define cmpnless_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 6)

Definition at line 845 of file sse.h.

#define cmpnltps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 5)

Definition at line 802 of file sse.h.

#define cmpnltps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 5)

Definition at line 800 of file sse.h.

#define cmpnltps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 5)

Definition at line 801 of file sse.h.

#define cmpnltss (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 5)

Definition at line 842 of file sse.h.

#define cmpnltss_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 5)

Definition at line 840 of file sse.h.

#define cmpnltss_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 5)

Definition at line 841 of file sse.h.

#define cmpordps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 7)

Definition at line 810 of file sse.h.

#define cmpordps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 7)

Definition at line 808 of file sse.h.

#define cmpordps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 7)

Definition at line 809 of file sse.h.

#define cmpordss (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 7)

Definition at line 850 of file sse.h.

#define cmpordss_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 7)

Definition at line 848 of file sse.h.

#define cmpordss_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 7)

Definition at line 849 of file sse.h.

#define cmpps (   vars,
  vard,
  op,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, op)

Definition at line 778 of file sse.h.

#define cmpps_m2r (   var,
  reg,
  op 
)    sse_m2ri(cmpps, var, reg, op)

Definition at line 776 of file sse.h.

#define cmpps_r2r (   regs,
  regd,
  op 
)    sse_r2ri(cmpps, regs, regd, op)

Definition at line 777 of file sse.h.

#define cmpss (   vars,
  vard,
  op,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, op)

Definition at line 818 of file sse.h.

#define cmpss_m2r (   var,
  reg,
  op 
)    sse_m2ri(cmpss, var, reg, op)

Definition at line 816 of file sse.h.

#define cmpss_r2r (   regs,
  regd,
  op 
)    sse_r2ri(cmpss, regs, regd, op)

Definition at line 817 of file sse.h.

#define cmpunordps (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpps, vars, vard, xmmreg, 3)

Definition at line 794 of file sse.h.

#define cmpunordps_m2r (   var,
  reg 
)    sse_m2ri(cmpps, var, reg, 3)

Definition at line 792 of file sse.h.

#define cmpunordps_r2r (   regs,
  regd 
)    sse_r2ri(cmpps, regs, regd, 3)

Definition at line 793 of file sse.h.

#define cmpunordss (   vars,
  vard,
  xmmreg 
)    sse_m2mi(cmpss, vars, vard, xmmreg, 3)

Definition at line 834 of file sse.h.

#define cmpunordss_m2r (   var,
  reg 
)    sse_m2ri(cmpss, var, reg, 3)

Definition at line 832 of file sse.h.

#define cmpunordss_r2r (   regs,
  regd 
)    sse_r2ri(cmpss, regs, regd, 3)

Definition at line 833 of file sse.h.

#define comiss (   vars,
  vard,
  xmmreg 
)    sse_m2m(comiss, vars, vard, xmmreg)

Definition at line 858 of file sse.h.

#define comiss_m2r (   var,
  reg 
)    sse_m2r(comiss, var, reg)

Definition at line 856 of file sse.h.

#define comiss_r2r (   regs,
  regd 
)    sse_r2r(comiss, regs, regd)

Definition at line 857 of file sse.h.

#define cvtpi2ps_m2r (   var,
  xmmreg 
)    sse_m2r(cvtpi2ps, var, xmmreg)

Definition at line 498 of file sse.h.

#define cvtpi2ps_r2r (   mmreg,
  xmmreg 
)    sse_r2r(cvtpi2ps, mmreg, xmmreg)

Definition at line 499 of file sse.h.

#define cvtps2pi_m2r (   var,
  mmreg 
)    sse_m2r(cvtps2pi, var, mmreg)

Definition at line 504 of file sse.h.

#define cvtps2pi_r2r (   xmmreg,
  mmreg 
)    sse_r2r(cvtps2pi, mmreg, xmmreg)

Definition at line 505 of file sse.h.

#define cvtsi2ss_m2r (   var,
  xmmreg 
)    sse_m2r(cvtsi2ss, var, xmmreg)

Definition at line 516 of file sse.h.

#define cvtsi2ss_r2r (   reg,
  xmmreg 
)    sse_r2r(cvtsi2ss, reg, xmmreg)

Definition at line 517 of file sse.h.

#define cvtss2si_m2r (   var,
  reg 
)    sse_m2r(cvtss2si, var, reg)

Definition at line 522 of file sse.h.

#define cvtss2si_r2r (   xmmreg,
  reg 
)    sse_r2r(cvtss2si, xmmreg, reg)

Definition at line 523 of file sse.h.

#define cvttps2pi_m2r (   var,
  mmreg 
)    sse_m2r(cvttps2pi, var, mmreg)

Definition at line 510 of file sse.h.

#define cvttps2pi_r2r (   xmmreg,
  mmreg 
)    sse_r2r(cvttps2pi, mmreg, xmmreg)

Definition at line 511 of file sse.h.

#define cvttss2si_m2r (   var,
  reg 
)    sse_m2r(cvtss2si, var, reg)

Definition at line 528 of file sse.h.

#define cvttss2si_r2r (   xmmreg,
  reg 
)    sse_r2r(cvtss2si, xmmreg, reg)

Definition at line 529 of file sse.h.

#define divps (   vars,
  vard,
  xmmreg 
)    sse_m2m(divps, vars, vard, xmmreg)

Definition at line 638 of file sse.h.

#define divps_m2r (   var,
  reg 
)    sse_m2r(divps, var, reg)

Definition at line 636 of file sse.h.

#define divps_r2r (   regs,
  regd 
)    sse_r2r(divps, regs, regd)

Definition at line 637 of file sse.h.

#define divss (   vars,
  vard,
  xmmreg 
)    sse_m2m(divss, vars, vard, xmmreg)

Definition at line 645 of file sse.h.

#define divss_m2r (   var,
  reg 
)    sse_m2r(divss, var, reg)

Definition at line 643 of file sse.h.

#define divss_r2r (   regs,
  regd 
)    sse_r2r(divss, regs, regd)

Definition at line 644 of file sse.h.

#define fxrstor (   mem)
Value:
__asm__ __volatile__ ("fxrstor %0" \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 897 of file sse.h.

#define fxsave (   mem)
Value:
__asm__ __volatile__ ("fxsave %0" \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 915 of file sse.h.

#define ldmxcsr (   mem)
Value:
__asm__ __volatile__ ("ldmxcsr %0" \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 951 of file sse.h.

#define maskmovq (   mmregs,
  fieldreg 
)    sse_r2ri(maskmovq, mmregs, fieldreg)

Definition at line 573 of file sse.h.

#define maxps (   vars,
  vard,
  xmmreg 
)    sse_m2m(maxps, vars, vard, xmmreg)

Definition at line 741 of file sse.h.

#define maxps_m2r (   var,
  reg 
)    sse_m2r(maxps, var, reg)

Definition at line 739 of file sse.h.

#define maxps_r2r (   regs,
  regd 
)    sse_r2r(maxps, regs, regd)

Definition at line 740 of file sse.h.

#define maxss (   vars,
  vard,
  xmmreg 
)    sse_m2m(maxss, vars, vard, xmmreg)

Definition at line 748 of file sse.h.

#define maxss_m2r (   var,
  reg 
)    sse_m2r(maxss, var, reg)

Definition at line 746 of file sse.h.

#define maxss_r2r (   regs,
  regd 
)    sse_r2r(maxss, regs, regd)

Definition at line 747 of file sse.h.

#define minps (   vars,
  vard,
  xmmreg 
)    sse_m2m(minps, vars, vard, xmmreg)

Definition at line 763 of file sse.h.

#define minps_m2r (   var,
  reg 
)    sse_m2r(minps, var, reg)

Definition at line 761 of file sse.h.

#define minps_r2r (   regs,
  regd 
)    sse_r2r(minps, regs, regd)

Definition at line 762 of file sse.h.

#define minss (   vars,
  vard,
  xmmreg 
)    sse_m2m(minss, vars, vard, xmmreg)

Definition at line 770 of file sse.h.

#define minss_m2r (   var,
  reg 
)    sse_m2r(minss, var, reg)

Definition at line 768 of file sse.h.

#define minss_r2r (   regs,
  regd 
)    sse_r2r(minss, regs, regd)

Definition at line 769 of file sse.h.

#define movaps (   vars,
  vard 
)
Value:
__asm__ __volatile__ ("movaps %1, %%mm0\n\t" \
                              "movaps %%mm0, %0" \
                              : "=X" (vard) \
                              : "X" (vars))

Definition at line 406 of file sse.h.

#define movaps_m2r (   var,
  reg 
)    sse_m2r(movaps, var, reg)

Definition at line 403 of file sse.h.

#define movaps_r2m (   reg,
  var 
)    sse_r2m(movaps, reg, var)

Definition at line 404 of file sse.h.

#define movaps_r2r (   regs,
  regd 
)    sse_r2r(movaps, regs, regd)

Definition at line 405 of file sse.h.

#define movhlps_r2r (   regs,
  regd 
)    sse_r2r(movhlps, regs, regd)

Definition at line 438 of file sse.h.

#define movhps (   vars,
  vard 
)
Value:
__asm__ __volatile__ ("movhps %1, %%mm0\n\t" \
                              "movhps %%mm0, %0" \
                              : "=X" (vard) \
                              : "X" (vars))

Definition at line 452 of file sse.h.

#define movhps_m2r (   var,
  reg 
)    sse_m2r(movhps, var, reg)

Definition at line 450 of file sse.h.

#define movhps_r2m (   reg,
  var 
)    sse_r2m(movhps, reg, var)

Definition at line 451 of file sse.h.

#define movlhps_r2r (   regs,
  regd 
)    sse_r2r(movlhps, regs, regd)

Definition at line 444 of file sse.h.

#define movlps (   vars,
  vard 
)
Value:
__asm__ __volatile__ ("movlps %1, %%mm0\n\t" \
                              "movlps %%mm0, %0" \
                              : "=X" (vard) \
                              : "X" (vars))

Definition at line 464 of file sse.h.

#define movlps_m2r (   var,
  reg 
)    sse_m2r(movlps, var, reg)

Definition at line 462 of file sse.h.

#define movlps_r2m (   reg,
  var 
)    sse_r2m(movlps, reg, var)

Definition at line 463 of file sse.h.

#define movmskps (   xmmreg,
  reg 
)    __asm__ __volatile__ ("movmskps %" #xmmreg ", %" #reg)

Definition at line 552 of file sse.h.

#define movntps_r2m (   xmmreg,
  var 
)    sse_r2m(movntps, xmmreg, var)

Definition at line 415 of file sse.h.

#define movntq_r2m (   mmreg,
  var 
)    sse_r2m(movntq, mmreg, var)

Definition at line 420 of file sse.h.

#define movss (   vars,
  vard 
)
Value:
__asm__ __volatile__ ("movss %1, %%mm0\n\t" \
                              "movss %%mm0, %0" \
                              : "=X" (vard) \
                              : "X" (vars))

Definition at line 477 of file sse.h.

#define movss_m2r (   var,
  reg 
)    sse_m2r(movss, var, reg)

Definition at line 474 of file sse.h.

#define movss_r2m (   reg,
  var 
)    sse_r2m(movss, reg, var)

Definition at line 475 of file sse.h.

#define movss_r2r (   regs,
  regd 
)    sse_r2r(movss, regs, regd)

Definition at line 476 of file sse.h.

#define movups (   vars,
  vard 
)
Value:
__asm__ __volatile__ ("movups %1, %%mm0\n\t" \
                              "movups %%mm0, %0" \
                              : "=X" (vard) \
                              : "X" (vars))

Definition at line 428 of file sse.h.

#define movups_m2r (   var,
  reg 
)    sse_m2r(movups, var, reg)

Definition at line 425 of file sse.h.

#define movups_r2m (   reg,
  var 
)    sse_r2m(movups, reg, var)

Definition at line 426 of file sse.h.

#define movups_r2r (   regs,
  regd 
)    sse_r2r(movups, regs, regd)

Definition at line 427 of file sse.h.

#define mulps (   vars,
  vard,
  xmmreg 
)    sse_m2m(mulps, vars, vard, xmmreg)

Definition at line 624 of file sse.h.

#define mulps_m2r (   var,
  reg 
)    sse_m2r(mulps, var, reg)

Definition at line 622 of file sse.h.

#define mulps_r2r (   regs,
  regd 
)    sse_r2r(mulps, regs, regd)

Definition at line 623 of file sse.h.

#define mulss (   vars,
  vard,
  xmmreg 
)    sse_m2m(mulss, vars, vard, xmmreg)

Definition at line 631 of file sse.h.

#define mulss_m2r (   var,
  reg 
)    sse_m2r(mulss, var, reg)

Definition at line 629 of file sse.h.

#define mulss_r2r (   regs,
  regd 
)    sse_r2r(mulss, regs, regd)

Definition at line 630 of file sse.h.

#define orps (   vars,
  vard,
  xmmreg 
)    sse_m2m(orps, vars, vard, xmmreg)

Definition at line 719 of file sse.h.

#define orps_m2r (   var,
  reg 
)    sse_m2r(orps, var, reg)

Definition at line 717 of file sse.h.

#define orps_r2r (   regs,
  regd 
)    sse_r2r(orps, regs, regd)

Definition at line 718 of file sse.h.

#define pavgb (   vars,
  vard,
  mmreg 
)    sse_m2m(pavgb, vars, vard, mmreg)

Definition at line 694 of file sse.h.

#define pavgb_m2r (   var,
  reg 
)    sse_m2r(pavgb, var, reg)

Definition at line 692 of file sse.h.

#define pavgb_r2r (   regs,
  regd 
)    sse_r2r(pavgb, regs, regd)

Definition at line 693 of file sse.h.

#define pavgw (   vars,
  vard,
  mmreg 
)    sse_m2m(pavgw, vars, vard, mmreg)

Definition at line 698 of file sse.h.

#define pavgw_m2r (   var,
  reg 
)    sse_m2r(pavgw, var, reg)

Definition at line 696 of file sse.h.

#define pavgw_r2r (   regs,
  regd 
)    sse_r2r(pavgw, regs, regd)

Definition at line 697 of file sse.h.

#define pextrw_r2r (   mmreg,
  reg,
  field 
)    sse_r2ri(pextrw, mmreg, reg, field)

Definition at line 534 of file sse.h.

#define pinsrw_r2r (   reg,
  mmreg,
  field 
)    sse_r2ri(pinsrw, reg, mmreg, field)

Definition at line 539 of file sse.h.

#define pmaxsw (   vars,
  vard,
  mmreg 
)    sse_m2m(pmaxsw, vars, vard, mmreg)

Definition at line 737 of file sse.h.

#define pmaxsw_m2r (   var,
  reg 
)    sse_m2r(pmaxsw, var, reg)

Definition at line 735 of file sse.h.

#define pmaxsw_r2r (   regs,
  regd 
)    sse_r2r(pmaxsw, regs, regd)

Definition at line 736 of file sse.h.

#define pmaxub (   vars,
  vard,
  mmreg 
)    sse_m2m(pmaxub, vars, vard, mmreg)

Definition at line 733 of file sse.h.

#define pmaxub_m2r (   var,
  reg 
)    sse_m2r(pmaxub, var, reg)

Definition at line 731 of file sse.h.

#define pmaxub_r2r (   regs,
  regd 
)    sse_r2r(pmaxub, regs, regd)

Definition at line 732 of file sse.h.

#define pminsw (   vars,
  vard,
  mmreg 
)    sse_m2m(pminsw, vars, vard, mmreg)

Definition at line 759 of file sse.h.

#define pminsw_m2r (   var,
  reg 
)    sse_m2r(pminsw, var, reg)

Definition at line 757 of file sse.h.

#define pminsw_r2r (   regs,
  regd 
)    sse_r2r(pminsw, regs, regd)

Definition at line 758 of file sse.h.

#define pminub (   vars,
  vard,
  mmreg 
)    sse_m2m(pminub, vars, vard, mmreg)

Definition at line 755 of file sse.h.

#define pminub_m2r (   var,
  reg 
)    sse_m2r(pminub, var, reg)

Definition at line 753 of file sse.h.

#define pminub_r2r (   regs,
  regd 
)    sse_r2r(pminub, regs, regd)

Definition at line 754 of file sse.h.

#define pmovmskb (   mmreg,
  reg 
)    __asm__ __volatile__ ("movmskps %" #mmreg ", %" #reg)

Definition at line 566 of file sse.h.

#define pmulhuw (   vars,
  vard,
  mmreg 
)    sse_m2m(pmulhuw, vars, vard, mmreg)

Definition at line 617 of file sse.h.

#define pmulhuw_m2r (   var,
  reg 
)    sse_m2r(pmulhuw, var, reg)

Definition at line 615 of file sse.h.

#define pmulhuw_r2r (   regs,
  regd 
)    sse_r2r(pmulhuw, regs, regd)

Definition at line 616 of file sse.h.

#define prefetch (   mem,
  hint 
)
Value:
__asm__ __volatile__ ("prefetch" #hint " %0" \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 981 of file sse.h.

#define prefetchnta (   mem)    prefetch(mem, nta)

Definition at line 989 of file sse.h.

Referenced by PLearn::bprop_update_layer().

#define prefetcht0 (   mem)    prefetch(mem, t0)

Definition at line 986 of file sse.h.

#define prefetcht1 (   mem)    prefetch(mem, t1)

Definition at line 987 of file sse.h.

#define prefetcht2 (   mem)    prefetch(mem, t2)

Definition at line 988 of file sse.h.

#define psadbw (   vars,
  vard,
  mmreg 
)    sse_m2m(psadbw, vars, vard, mmreg)

Definition at line 610 of file sse.h.

#define psadbw_m2r (   var,
  reg 
)    sse_m2r(psadbw, var, reg)

Definition at line 608 of file sse.h.

#define psadbw_r2r (   regs,
  regd 
)    sse_r2r(psadbw, regs, regd)

Definition at line 609 of file sse.h.

#define pshufw_m2r (   var,
  reg,
  index 
)    sse_m2ri(pshufw, var, reg, index)

Definition at line 486 of file sse.h.

#define pshufw_r2r (   regs,
  regd,
  index 
)    sse_r2ri(pshufw, regs, regd, index)

Definition at line 487 of file sse.h.

#define rcpps (   vars,
  vard,
  xmmreg 
)    sse_m2m(rcpps, vars, vard, xmmreg)

Definition at line 652 of file sse.h.

#define rcpps_m2r (   var,
  reg 
)    sse_m2r(rcpps, var, reg)

Definition at line 650 of file sse.h.

#define rcpps_r2r (   regs,
  regd 
)    sse_r2r(rcpps, regs, regd)

Definition at line 651 of file sse.h.

#define rcpss (   vars,
  vard,
  xmmreg 
)    sse_m2m(rcpss, vars, vard, xmmreg)

Definition at line 659 of file sse.h.

#define rcpss_m2r (   var,
  reg 
)    sse_m2r(rcpss, var, reg)

Definition at line 657 of file sse.h.

#define rcpss_r2r (   regs,
  regd 
)    sse_r2r(rcpss, regs, regd)

Definition at line 658 of file sse.h.

#define rsqrtps (   vars,
  vard,
  xmmreg 
)    sse_m2m(rsqrtps, vars, vard, xmmreg)

Definition at line 666 of file sse.h.

#define rsqrtps_m2r (   var,
  reg 
)    sse_m2r(rsqrtps, var, reg)

Definition at line 664 of file sse.h.

#define rsqrtps_r2r (   regs,
  regd 
)    sse_r2r(rsqrtps, regs, regd)

Definition at line 665 of file sse.h.

#define rsqrtss (   vars,
  vard,
  xmmreg 
)    sse_m2m(rsqrtss, vars, vard, xmmreg)

Definition at line 673 of file sse.h.

#define rsqrtss_m2r (   var,
  reg 
)    sse_m2r(rsqrtss, var, reg)

Definition at line 671 of file sse.h.

#define rsqrtss_r2r (   regs,
  regd 
)    sse_r2r(rsqrtss, regs, regd)

Definition at line 672 of file sse.h.

#define sfence ( )    __asm__ __volatile__ ("sfence\n\t")

Definition at line 968 of file sse.h.

#define shufps_m2r (   var,
  reg,
  index 
)    sse_m2ri(shufps, var, reg, index)

Definition at line 492 of file sse.h.

#define shufps_r2r (   regs,
  regd,
  index 
)    sse_r2ri(shufps, regs, regd, index)

Definition at line 493 of file sse.h.

#define sqrtps (   vars,
  vard,
  xmmreg 
)    sse_m2m(sqrtps, vars, vard, xmmreg)

Definition at line 680 of file sse.h.

#define sqrtps_m2r (   var,
  reg 
)    sse_m2r(sqrtps, var, reg)

Definition at line 678 of file sse.h.

#define sqrtps_r2r (   regs,
  regd 
)    sse_r2r(sqrtps, regs, regd)

Definition at line 679 of file sse.h.

#define sqrtss (   vars,
  vard,
  xmmreg 
)    sse_m2m(sqrtss, vars, vard, xmmreg)

Definition at line 687 of file sse.h.

#define sqrtss_m2r (   var,
  reg 
)    sse_m2r(sqrtss, var, reg)

Definition at line 685 of file sse.h.

#define sqrtss_r2r (   regs,
  regd 
)    sse_r2r(sqrtss, regs, regd)

Definition at line 686 of file sse.h.

#define sse_i2r (   op,
  imm,
  reg 
)
Value:
__asm__ __volatile__ (#op " %0, %%" #reg \
                              : /* nothing */ \
                              : "X" (imm) )

Definition at line 354 of file sse.h.

#define sse_m2m (   op,
  mems,
  memd,
  xmmreg 
)
Value:
__asm__ __volatile__ ("movups %0, %%xmm0\n\t" \
                              #op " %1, %%xmm0\n\t" \
                              "movups %%xmm0, %0" \
                              : "=X" (memd) \
                              : "X" (mems))

Definition at line 378 of file sse.h.

#define sse_m2mi (   op,
  mems,
  memd,
  xmmreg,
  subop 
)
Value:
__asm__ __volatile__ ("movups %0, %%xmm0\n\t" \
                              #op " %1, %%xmm0, " #subop "\n\t" \
                              "movups %%mm0, %0" \
                              : "=X" (memd) \
                              : "X" (mems))

Definition at line 390 of file sse.h.

#define sse_m2r (   op,
  mem,
  reg 
)
Value:
__asm__ __volatile__ (#op " %0, %%" #reg \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 359 of file sse.h.

#define sse_m2ri (   op,
  mem,
  reg,
  subop 
)
Value:
__asm__ __volatile__ (#op " %0, %%" #reg ", " #subop \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 385 of file sse.h.

#define sse_r2m (   op,
  reg,
  mem 
)
Value:
__asm__ __volatile__ (#op " %%" #reg ", %0" \
                              : "=X" (mem) \
                              : /* nothing */ )

Definition at line 364 of file sse.h.

#define sse_r2r (   op,
  regs,
  regd 
)    __asm__ __volatile__ (#op " %" #regs ", %" #regd)

Definition at line 369 of file sse.h.

#define sse_r2ri (   op,
  regs,
  regd,
  imm 
)
Value:
__asm__ __volatile__ (#op " %%" #regs ", %%" #regd ", %0" \
                              : /* nothing */ \
                              : "X" (imm) )

Definition at line 372 of file sse.h.

#define stmxcsr (   mem)
Value:
__asm__ __volatile__ ("stmxcsr %0" \
                              : /* nothing */ \
                              : "X" (mem))

Definition at line 933 of file sse.h.

#define subps (   vars,
  vard,
  xmmreg 
)    sse_m2m(subps, vars, vard, xmmreg)

Definition at line 596 of file sse.h.

#define subps_m2r (   var,
  reg 
)    sse_m2r(subps, var, reg)

Definition at line 594 of file sse.h.

#define subps_r2r (   regs,
  regd 
)    sse_r2r(subps, regs, regd)

Definition at line 595 of file sse.h.

#define subss (   vars,
  vard,
  xmmreg 
)    sse_m2m(subss, vars, vard, xmmreg)

Definition at line 603 of file sse.h.

#define subss_m2r (   var,
  reg 
)    sse_m2r(subss, var, reg)

Definition at line 601 of file sse.h.

#define subss_r2r (   regs,
  regd 
)    sse_r2r(subss, regs, regd)

Definition at line 602 of file sse.h.

#define ucomiss (   vars,
  vard,
  xmmreg 
)    sse_m2m(ucomiss, vars, vard, xmmreg)

Definition at line 866 of file sse.h.

#define ucomiss_m2r (   var,
  reg 
)    sse_m2r(ucomiss, var, reg)

Definition at line 864 of file sse.h.

#define ucomiss_r2r (   regs,
  regd 
)    sse_r2r(ucomiss, regs, regd)

Definition at line 865 of file sse.h.

#define unpckhps_m2r (   var,
  reg 
)    sse_m2r(unpckhps, var, reg)

Definition at line 881 of file sse.h.

#define unpckhps_r2r (   regs,
  regd 
)    sse_r2r(unpckhps, regs, regd)

Definition at line 882 of file sse.h.

#define unpcklps_m2r (   var,
  reg 
)    sse_m2r(unpcklps, var, reg)

Definition at line 873 of file sse.h.

#define unpcklps_r2r (   regs,
  regd 
)    sse_r2r(unpcklps, regs, regd)

Definition at line 874 of file sse.h.

#define xorps (   vars,
  vard,
  xmmreg 
)    sse_m2m(xorps, vars, vard, xmmreg)

Definition at line 726 of file sse.h.

#define xorps_m2r (   var,
  reg 
)    sse_m2r(xorps, var, reg)

Definition at line 724 of file sse.h.

#define xorps_r2r (   regs,
  regd 
)    sse_r2r(xorps, regs, regd)

Definition at line 725 of file sse.h.


Function Documentation

int mm_support ( void  ) [inline]

Definition at line 54 of file sse.h.

Referenced by sse_ok().

{
    /* Returns 1 if MMX instructions are supported,
       3 if Cyrix MMX and Extended MMX instructions are supported
       5 if AMD MMX and 3DNow! instructions are supported
       9 if MMX and SSE instructions are supported
       0 if hardware does not support any of these
    */
    register int rval = 0;

    __asm__ __volatile__ (
        /* See if CPUID instruction is supported ... */
        /* ... Get copies of EFLAGS into eax and ecx */
        "pushf\n\t"
        "popl %%eax\n\t"
        "movl %%eax, %%ecx\n\t"

        /* ... Toggle the ID bit in one copy and store */
        /*     to the EFLAGS reg */
        "xorl $0x200000, %%eax\n\t"
        "push %%eax\n\t"
        "popf\n\t"

        /* ... Get the (hopefully modified) EFLAGS */
        "pushf\n\t"
        "popl %%eax\n\t"

        /* ... Compare and test result */
        "xorl %%eax, %%ecx\n\t"
        "testl $0x200000, %%ecx\n\t"
        "jz NotSupported1\n\t"          /* CPUID not supported */


        /* Get standard CPUID information, and
           go to a specific vendor section */
        "movl $0, %%eax\n\t"
        "cpuid\n\t"

        /* Check for Intel */
        "cmpl $0x756e6547, %%ebx\n\t"
        "jne TryAMD\n\t"
        "cmpl $0x49656e69, %%edx\n\t"
        "jne TryAMD\n\t"
        "cmpl $0x6c65746e, %%ecx\n"
        "jne TryAMD\n\t"
        "jmp Intel\n\t"

        /* Check for AMD */
        "\nTryAMD:\n\t"
        "cmpl $0x68747541, %%ebx\n\t"
        "jne TryCyrix\n\t"
        "cmpl $0x69746e65, %%edx\n\t"
        "jne TryCyrix\n\t"
        "cmpl $0x444d4163, %%ecx\n"
        "jne TryCyrix\n\t"
        "jmp AMD\n\t"

        /* Check for Cyrix */
        "\nTryCyrix:\n\t"
        "cmpl $0x69727943, %%ebx\n\t"
        "jne NotSupported2\n\t"
        "cmpl $0x736e4978, %%edx\n\t"
        "jne NotSupported3\n\t"
        "cmpl $0x64616574, %%ecx\n\t"
        "jne NotSupported4\n\t"
        /* Drop through to Cyrix... */


        /* Cyrix Section */
        /* See if extended CPUID level 80000001 is supported */
        /* The value of CPUID/80000001 for the 6x86MX is undefined
           according to the Cyrix CPU Detection Guide (Preliminary
           Rev. 1.01 table 1), so we'll check the value of eax for
           CPUID/0 to see if standard CPUID level 2 is supported.
           According to the table, the only CPU which supports level
           2 is also the only one which supports extended CPUID levels.
        */
        "cmpl $0x2, %%eax\n\t"
        "jne MMXtest\n\t"       /* Use standard CPUID instead */

        /* Extended CPUID supported (in theory), so get extended
           features */
        "movl $0x80000001, %%eax\n\t"
        "cpuid\n\t"
        "testl $0x00800000, %%eax\n\t"  /* Test for MMX */
        "jz NotSupported5\n\t"          /* MMX not supported */
        "testl $0x01000000, %%eax\n\t"  /* Test for Ext'd MMX */
        "jnz EMMXSupported\n\t"
        "movl $1, %0:\n\n\t"            /* MMX Supported */
        "jmp Return\n\n"
        "EMMXSupported:\n\t"
        "movl $3, %0:\n\n\t"            /* EMMX and MMX Supported */
        "jmp Return\n\t"


        /* AMD Section */
        "AMD:\n\t"

        /* See if extended CPUID is supported */
        "movl $0x80000000, %%eax\n\t"
        "cpuid\n\t"
        "cmpl $0x80000000, %%eax\n\t"
        "jl MMXtest\n\t"        /* Use standard CPUID instead */

        /* Extended CPUID supported, so get extended features */
        "movl $0x80000001, %%eax\n\t"
        "cpuid\n\t"
        "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
        "jz NotSupported6\n\t"          /* MMX not supported */
        "testl $0x80000000, %%edx\n\t"  /* Test for 3DNow! */
        "jnz ThreeDNowSupported\n\t"
        "movl $1, %0:\n\n\t"            /* MMX Supported */
        "jmp Return\n\n"
        "ThreeDNowSupported:\n\t"
        "movl $5, %0:\n\n\t"            /* 3DNow! and MMX Supported */
        "jmp Return\n\t"


        /* Intel Section */
        "Intel:\n\t"

        /* Check for SSE */
        "SSEtest:\n\t"
        "movl $1, %%eax\n\t"
        "cpuid\n\t"
        "testl $0x02000000, %%edx\n\t"  /* Test for SSE */
        "jz MMXtest\n\t"                /* SSE Not supported */
        "movl $9, %0:\n\n\t"            /* SSE Supported */
        "jmp Return\n\t"

        /* Check for MMX */
        "MMXtest:\n\t"
        "movl $1, %%eax\n\t"
        "cpuid\n\t"
        "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
        "jz NotSupported7\n\t"          /* MMX Not supported */
        "movl $1, %0:\n\n\t"            /* MMX Supported */
        "jmp Return\n\t"

        /* Nothing supported */
        "\nNotSupported1:\n\t"
        "#movl $101, %0:\n\n\t"
        "\nNotSupported2:\n\t"
        "#movl $102, %0:\n\n\t"
        "\nNotSupported3:\n\t"
        "#movl $103, %0:\n\n\t"
        "\nNotSupported4:\n\t"
        "#movl $104, %0:\n\n\t"
        "\nNotSupported5:\n\t"
        "#movl $105, %0:\n\n\t"
        "\nNotSupported6:\n\t"
        "#movl $106, %0:\n\n\t"
        "\nNotSupported7:\n\t"
        "#movl $107, %0:\n\n\t"
        "movl $0, %0:\n\n\t"

        "Return:\n\t"
        : "=a" (rval)
        : /* no input */
        : "eax", "ebx", "ecx", "edx"
        );

    /* Return */
    return(rval);
}

Here is the caller graph for this function:

int sse_ok ( void  ) [inline]

Definition at line 223 of file sse.h.

References mm_support().

{
    /* Returns 1 if SSE instructions are supported, 0 otherwise */
    return ( (mm_support() & 0x8) >> 3  );
}

Here is the call graph for this function:

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines