---

x86istri.h

Go to the documentation of this file.

/*
PeRdr - PE file disassembler
Copyright (C) 1999-2002 Frediano Ziglio
-----

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-----

INFORMATION
  www: https://freddy77.tripod.com/perdr/
  e-mail: freddy77@angelfire.com
*/
BEGIN_ISTR
  DEFINE_ISTR2(aaa,if),
  DEFINE_ISTR2(aad,if),
  DEFINE_ISTR2(aam,if),
  DEFINE_ISTR2(aas,if),
  DEFINE_ISTR2(adc,if),
  DEFINE_ISTR2(add,if),
  DEFINE_ISTR2(and,if),
  DEFINE_ISTR(arpl),
  DEFINE_ISTR2(bound,i), // accede a interi ma non accede ai flag
  DEFINE_ISTR2(bsf,if),
  DEFINE_ISTR2(bsr,if),
  DEFINE_ISTR2(bswap,i),
  DEFINE_ISTR2(bt,if),
  DEFINE_ISTR2(btc,if),
  DEFINE_ISTR2(btr,if),
  DEFINE_ISTR2(bts,if),
  DEFINE_ISTR2(call,is), // flag cambiati solo se call a task
  DEFINE_ISTR2(cbw,is),
  DEFINE_ISTR2(cdq,is),
  DEFINE_ISTR2(clc,f),
  DEFINE_ISTR2(cld,f),
  DEFINE_ISTR2(cli,f),
  DEFINE_ISTR(clts),
  DEFINE_ISTR2(cmc,f),
  DEFINE_ISTR2(cmovb,if), // flag solo lettura
  DEFINE_ISTR2(cmovbe,if),
  DEFINE_ISTR2(cmovl,if),
  DEFINE_ISTR2(cmovle,if),
  DEFINE_ISTR2(cmovnb,if),
  DEFINE_ISTR2(cmovnbe,if),
  DEFINE_ISTR2(cmovnl,if),
  DEFINE_ISTR2(cmovnle,if),
  DEFINE_ISTR2(cmovno,if),
  DEFINE_ISTR2(cmovnp,if),
  DEFINE_ISTR2(cmovns,if),
  DEFINE_ISTR2(cmovnz,if),
  DEFINE_ISTR2(cmovo,if),
  DEFINE_ISTR2(cmovp,if),
  DEFINE_ISTR2(cmovs,if),
  DEFINE_ISTR2(cmovz,if),
  DEFINE_ISTR2(cmp,if),
  DEFINE_ISTR2(cmpsb,isf),
  DEFINE_ISTR2(cmpsw,isf),
  DEFINE_ISTR2(cmpsd,isf),
  DEFINE_ISTR2(cmpxchg,if),
  DEFINE_ISTR2(cmpxchg8b,isf),
  DEFINE_ISTR2(cpuid,i),
  DEFINE_ISTR2(cwd,is),
  DEFINE_ISTR2(cwde,is),
  DEFINE_ISTR2(daa,isf),
  DEFINE_ISTR2(das,isf),
  DEFINE_ISTR2(dec,if),
  DEFINE_ISTR2(div,isf),
  DEFINE_ISTR2(emms,none),  // modifica uno registri FPU per poterli usare come FP
  DEFINE_ISTR2(enter,is),
  DEFINE_ISTR(esc),
  DEFINE_ISTR2(f2xm1,F),  // floating-point instruction
  DEFINE_ISTR2(fabs,F),
  DEFINE_ISTR2(fadd,F),
  DEFINE_ISTR2(faddp,F),
  DEFINE_ISTR2(fbld,F),
  DEFINE_ISTR2(fbstp,F),
  DEFINE_ISTR2(fchs,F),
  DEFINE_ISTR2(fclex,none), // non modifica registri FPU, solo stato
  DEFINE_ISTR2(fcmovb,Ff),
  DEFINE_ISTR2(fcmovbe,Ff),
  DEFINE_ISTR2(fcmove,Ff),
  DEFINE_ISTR2(fcmovnb,Ff),
  DEFINE_ISTR2(fcmovnbe,Ff),
  DEFINE_ISTR2(fcmovne,Ff),
  DEFINE_ISTR2(fcmovnu,Ff),
  DEFINE_ISTR2(fcmovu,Ff),
  DEFINE_ISTR2(fcom,F),
  DEFINE_ISTR2(fcomi,Ff),
  DEFINE_ISTR2(fcomip,Ff),
  DEFINE_ISTR2(fcomp,F),
  DEFINE_ISTR2(fcompp,F),
  DEFINE_ISTR2(fcos,F),
  DEFINE_ISTR2(fdecstp,none), // modifica solo FPU stack
  DEFINE_ISTR(fdisi),
  DEFINE_ISTR2(fdiv,F),
  DEFINE_ISTR2(fdivp,F),
  DEFINE_ISTR2(fdivr,F),
  DEFINE_ISTR2(fdivrp,F),
  DEFINE_ISTR(feni),
  DEFINE_ISTR2(ffree,F),
  DEFINE_ISTR2(fiadd,F),
  DEFINE_ISTR2(ficom,F),
  DEFINE_ISTR2(ficomp,F),
  DEFINE_ISTR2(fidiv,F),
  DEFINE_ISTR2(fidivr,F),
  DEFINE_ISTR2(fild,F),
  DEFINE_ISTR2(fimul,F),
  DEFINE_ISTR2(fincstp,none),
  DEFINE_ISTR2(finit,none), // non tocca registri ??
  DEFINE_ISTR2(fist,F),
  DEFINE_ISTR2(fistp,F),
  DEFINE_ISTR2(fisub,F),
  DEFINE_ISTR2(fisubr,F),
  DEFINE_ISTR2(fld,F),
  DEFINE_ISTR2(fldcw,none), // ??? puo' caricare da registro16
  DEFINE_ISTR2(fldenv,none),
  DEFINE_ISTR2(fldl,F),
  DEFINE_ISTR2(fldl2e,F),
  DEFINE_ISTR2(fldl2t,F),
  DEFINE_ISTR2(fldlg2,F),
  DEFINE_ISTR2(fldln2,F),
  DEFINE_ISTR2(fldpi,F),
  DEFINE_ISTR2(fldz,F),
  DEFINE_ISTR2(fmul,F),
  DEFINE_ISTR2(fmulp,F),
  DEFINE_ISTR2(fnop,none),
  DEFINE_ISTR2(fnsave,F),
  DEFINE_ISTR2(fnstcw,none), // e se usa destinazione reg16 ??
  DEFINE_ISTR2(fnstenv,none),
  DEFINE_ISTR2(fnstsw,i), // usa anche stato FPU
  DEFINE_ISTR2(fpatan,F),
  DEFINE_ISTR2(fprem,F),
  DEFINE_ISTR2(fpreml,F),
  DEFINE_ISTR2(fptan,F),
  DEFINE_ISTR2(frndint,F),
  DEFINE_ISTR2(frstor,F), // ripristina stato FPU
  DEFINE_ISTR2(fscale,F),
  DEFINE_ISTR(fsetpm),
  DEFINE_ISTR2(fsin,F),
  DEFINE_ISTR2(fsincos,F),
  DEFINE_ISTR2(fsqrt,F),
  DEFINE_ISTR2(fst,F),
  DEFINE_ISTR2(fstp,F),
  DEFINE_ISTR(fstsw),  // !!! non dovrebbe essere fnstsw
  DEFINE_ISTR2(fsub,F),
  DEFINE_ISTR2(fsubp,F),
  DEFINE_ISTR2(fsubr,F),
  DEFINE_ISTR2(fsubrp,F),
  DEFINE_ISTR2(ftst,F),
  DEFINE_ISTR2(fucom,F),
  DEFINE_ISTR2(fucomi,Ff),
  DEFINE_ISTR2(fucomip,Ff),
  DEFINE_ISTR2(fucomp,F),
  DEFINE_ISTR(fucompuu),  //??
  DEFINE_ISTR2(fxam,F),
  DEFINE_ISTR2(fxch,F),
  DEFINE_ISTR2(fxtract,F),
  DEFINE_ISTR2(fyl2x,F),
  DEFINE_ISTR2(fyl2xpl,F),  // end floating-point instruction
  DEFINE_ISTR(fxrstor),
  DEFINE_ISTR(fxsave),
  DEFINE_ISTR2(hlt,none),
  DEFINE_ISTR2(idiv,isf),
  DEFINE_ISTR2(imul,isf),
  DEFINE_ISTR2(in,i),
  DEFINE_ISTR2(inc,i),
  DEFINE_ISTR2(insb,is),
  DEFINE_ISTR2(insw,is),
  DEFINE_ISTR2(insd,is),
  DEFINE_ISTR2(int,s),
  DEFINE_ISTR2(int3,s),
  DEFINE_ISTR2(into,sf),
  DEFINE_ISTR2(invd,none),
  DEFINE_ISTR2(invlpg,none), // usa registri solo come memoria
  DEFINE_ISTR2(iret,sf),
  DEFINE_ISTR2(jb,sf),
  DEFINE_ISTR2(jbe,sf),
  DEFINE_ISTR2(jc,sf),
  DEFINE_ISTR2(jcxz,isf),
  DEFINE_ISTR2(jg,sf),
  DEFINE_ISTR2(jl,sf),
  DEFINE_ISTR2(jle,sf),
  DEFINE_ISTR2(jmp,sf),
  DEFINE_ISTR2(jnb,sf),
  DEFINE_ISTR2(jnbe,sf),
  DEFINE_ISTR2(jnc,sf),
  DEFINE_ISTR2(jng,sf),
  DEFINE_ISTR2(jnl,sf),
  DEFINE_ISTR2(jnle,sf),
  DEFINE_ISTR2(jno,sf),
  DEFINE_ISTR2(jnp,sf),
  DEFINE_ISTR2(jns,sf),
  DEFINE_ISTR2(jnz,sf),
  DEFINE_ISTR2(jo,sf),
  DEFINE_ISTR2(jp,sf),
  DEFINE_ISTR2(js,sf),
  DEFINE_ISTR2(jz,sf),
  DEFINE_ISTR2(lahf,isf),
  DEFINE_ISTR(lar),
  DEFINE_ISTR(ldmxcsr),
  DEFINE_ISTR(lds),
  DEFINE_ISTR2(lea,is), // non accede alla memoria
  DEFINE_ISTR2(leave,is),
  DEFINE_ISTR(les),
  DEFINE_ISTR(lfs),
  DEFINE_ISTR(lgdt),
  DEFINE_ISTR(lgs),
  DEFINE_ISTR(lidt),
  DEFINE_ISTR(lldt),
  DEFINE_ISTR(lmsw),
  DEFINE_ISTR2(lock,s),
  DEFINE_ISTR2(lodsb,is),
  DEFINE_ISTR2(lodsw,is),
  DEFINE_ISTR2(lodsd,is),
  DEFINE_ISTR2(loop,is),
  DEFINE_ISTR2(loopnz,isf),
  DEFINE_ISTR2(loopz,isf),
  DEFINE_ISTR(lsl),
  DEFINE_ISTR(lss),
  DEFINE_ISTR(ltr),
  DEFINE_ISTR(maskmovq),
  DEFINE_ISTR2(mov,is), // !!! usa anche CR, ecc
  DEFINE_ISTR(movntq),
  DEFINE_ISTR2(movsb,is),
  DEFINE_ISTR2(movsw,is),
  DEFINE_ISTR2(movsd,is),
  DEFINE_ISTR2(movsx,is),
  DEFINE_ISTR2(movzx,is),
  DEFINE_ISTR2(mul,isf),
  DEFINE_ISTR2(neg,if),
  DEFINE_ISTR2(nop,none),
  DEFINE_ISTR2(not,i),
  DEFINE_ISTR2(or,if),
  DEFINE_ISTR2(out,i),
  DEFINE_ISTR2(outsb,is),
  DEFINE_ISTR2(outsw,is),
  DEFINE_ISTR2(outsd,is),
  DEFINE_ISTR(pextrw),
  DEFINE_ISTR(pmovmskb),
  DEFINE_ISTR2(pop,is),
  DEFINE_ISTR2(popa,is),
  DEFINE_ISTR2(popf,isf),
  DEFINE_ISTR2(prefetch0,s),
  DEFINE_ISTR2(prefetch1,s),
  DEFINE_ISTR2(prefetch2,s),
  DEFINE_ISTR2(prefetchnta,s),
  DEFINE_ISTR2(push,is),
  DEFINE_ISTR2(pusha,is),
  DEFINE_ISTR2(pushf,isf),

  DEFINE_ISTR2(movd,iM),   // MMX start
  DEFINE_ISTR2(movq,M),
  DEFINE_ISTR2(packssdw,M),
  DEFINE_ISTR2(packsswb,M),
  DEFINE_ISTR2(packusdw,M),
  DEFINE_ISTR2(paddb,M),
  DEFINE_ISTR2(paddd,M),
  DEFINE_ISTR2(paddsb,M),
  DEFINE_ISTR2(paddsw,M),
  DEFINE_ISTR2(paddusb,M),
  DEFINE_ISTR2(paddusw,M),
  DEFINE_ISTR2(paddw,M),
  DEFINE_ISTR2(pand,M),
  DEFINE_ISTR2(pandn,M),
  DEFINE_ISTR2(pavgb,M),
  DEFINE_ISTR2(pavgw,M),
  DEFINE_ISTR2(pcmpeqb,M),
  DEFINE_ISTR2(pcmpeqd,M),
  DEFINE_ISTR2(pcmpeqw,M),
  DEFINE_ISTR2(pcmpgtb,M),
  DEFINE_ISTR2(pcmpgtd,M),
  DEFINE_ISTR2(pcmpgtw,M),
  DEFINE_ISTR2(pinsrw,M),
  DEFINE_ISTR2(pminub,M),
  DEFINE_ISTR2(pminsw,M),
  DEFINE_ISTR2(pmaddwd,M),
  DEFINE_ISTR2(pmaxub,M),
  DEFINE_ISTR2(pmaxsw,M),
  DEFINE_ISTR2(pmulhuw,M),
  DEFINE_ISTR2(pmulhw,M),
  DEFINE_ISTR2(pmullw,M),
  DEFINE_ISTR2(por,M),
  DEFINE_ISTR2(psadbw,M),
  DEFINE_ISTR2(pshufw,M),
  DEFINE_ISTR2(pslld,M),
  DEFINE_ISTR2(psllq,M),
  DEFINE_ISTR2(psllw,M),
  DEFINE_ISTR2(psrad,M),
  DEFINE_ISTR2(psraw,M),
  DEFINE_ISTR2(psrld,M),
  DEFINE_ISTR2(psrlq,M),
  DEFINE_ISTR2(psrlw,M),
  DEFINE_ISTR2(psubb,M),
  DEFINE_ISTR2(psubd,M),
  DEFINE_ISTR2(psubsb,M),
  DEFINE_ISTR2(psubsw,M),
  DEFINE_ISTR2(psubusb,M),
  DEFINE_ISTR2(psubusw,M),
  DEFINE_ISTR2(psubw,M),
  DEFINE_ISTR2(punockldq,M),
  DEFINE_ISTR2(punpckhbw,M),
  DEFINE_ISTR2(punpckhdq,M),
  DEFINE_ISTR2(punpckhwd,M),
  DEFINE_ISTR2(punpcklbw,M),
  DEFINE_ISTR2(punpcklwd,M),
  DEFINE_ISTR2(pxor,M), // MMX end

  DEFINE_ISTR(movups),  // XMM
  DEFINE_ISTR(movaps),
  DEFINE_ISTR(movntps),
  DEFINE_ISTR(sqrtps),
  DEFINE_ISTR(rsqrtps),
  DEFINE_ISTR(rcpps),
  DEFINE_ISTR(andps),
  DEFINE_ISTR(andnps),
  DEFINE_ISTR(orps),
  DEFINE_ISTR(xorps),
  DEFINE_ISTR(addps),
  DEFINE_ISTR(mulps),
  DEFINE_ISTR(subps),
  DEFINE_ISTR(minps),
  DEFINE_ISTR(divps),
  DEFINE_ISTR(maxps),
  DEFINE_ISTR(cmpps),
  DEFINE_ISTR(shufps),
  DEFINE_ISTR(unpcklps),
  DEFINE_ISTR(unpckhps),
  DEFINE_ISTR(cvtpi2ps),
  DEFINE_ISTR(cvttps2pi),
  DEFINE_ISTR(cvtps2pi),
  DEFINE_ISTR(ucomiss),
  DEFINE_ISTR(comiss),
  DEFINE_ISTR(movmskps),
  DEFINE_ISTR(movlps),
  DEFINE_ISTR(movlhps),
  DEFINE_ISTR(movhps),
  DEFINE_ISTR(movhlps),
  DEFINE_ISTR(movss),
  DEFINE_ISTR(sqrtss),
  DEFINE_ISTR(rsqrtss),
  DEFINE_ISTR(rcpss),
  DEFINE_ISTR(cmpss),
  DEFINE_ISTR(cvtsi2ss),
  DEFINE_ISTR(cvttss2si),
  DEFINE_ISTR(cvtss2si),
  DEFINE_ISTR(addss),
  DEFINE_ISTR(mulss),
  DEFINE_ISTR(subss),
  DEFINE_ISTR(minss),
  DEFINE_ISTR(divss),
  DEFINE_ISTR(maxss),

  DEFINE_ISTR2(rcl,if),
  DEFINE_ISTR2(rcr,if),
  DEFINE_ISTR2(rdmsr,is),
  DEFINE_ISTR2(rdpmc,is),
  DEFINE_ISTR2(rdtsc,is),
  DEFINE_ISTR2(repnz,none), // speciali
  DEFINE_ISTR2(repz,none),
  DEFINE_ISTR2(ret,is), // esp
  DEFINE_ISTR2(retf,is),
  DEFINE_ISTR2(rol,if),
  DEFINE_ISTR2(ror,if),
  DEFINE_ISTR(rsm),
  DEFINE_ISTR2(sahf,isf),
  DEFINE_ISTR2(sar,if),
  DEFINE_ISTR2(sbb,if),
  DEFINE_ISTR2(scasb,isf),
  DEFINE_ISTR2(scasw,isf),
  DEFINE_ISTR2(scasd,isf),
  DEFINE_ISTR2(setb,if),  // speciali ?? overwrite 2 valori
  DEFINE_ISTR2(setbe,if),
  DEFINE_ISTR2(setl,if),
  DEFINE_ISTR2(setle,if),
  DEFINE_ISTR2(setnb,if),
  DEFINE_ISTR2(setnbe,if),
  DEFINE_ISTR2(setnl,if),
  DEFINE_ISTR2(setnle,if),
  DEFINE_ISTR2(setno,if),
  DEFINE_ISTR2(setnp,if),
  DEFINE_ISTR2(setns,if),
  DEFINE_ISTR2(setnz,if),
  DEFINE_ISTR2(seto,if),
  DEFINE_ISTR2(setp,if),
  DEFINE_ISTR2(sets,if),
  DEFINE_ISTR2(setz,if),
  DEFINE_ISTR2(sfence,s),
  DEFINE_ISTR(sgdt),
  DEFINE_ISTR2(shl,if),
  DEFINE_ISTR2(shld,if),
  DEFINE_ISTR2(shr,if),
  DEFINE_ISTR2(shrd,if),
  DEFINE_ISTR(sidt),
  DEFINE_ISTR(sldt),
  DEFINE_ISTR(smsw),
  DEFINE_ISTR2(stc,f),
  DEFINE_ISTR2(std,f),
  DEFINE_ISTR2(sti,f),
  DEFINE_ISTR(stmxcsr),
  DEFINE_ISTR2(stosb,is),
  DEFINE_ISTR2(stosw,is),
  DEFINE_ISTR2(stosd,is),
  DEFINE_ISTR(str),
  DEFINE_ISTR2(sub,if),
  DEFINE_ISTR2(sysenter,i),
  DEFINE_ISTR2(sysexit,i),
  DEFINE_ISTR2(test,if),
  DEFINE_ISTR(ud),
  DEFINE_ISTR(ud2),
  DEFINE_ISTR(verr),
  DEFINE_ISTR(verw),
  DEFINE_ISTR2(wait,none),
  DEFINE_ISTR2(wbinvd,none),
  DEFINE_ISTR2(wrmsr,is),
  DEFINE_ISTR2(xadd,isf), // scambia i valori
  DEFINE_ISTR2(xchg,is),
  DEFINE_ISTR2(xlat,is),
  DEFINE_ISTR2(xor,if),

  // 3D Now!
  DEFINE_ISTR(femms),
  DEFINE_ISTR(prefetch),
  DEFINE_ISTR(prefetchw),
  DEFINE_ISTR(pavgusb),
  DEFINE_ISTR(pf2id),
  DEFINE_ISTR(pf2iw),
  DEFINE_ISTR(pfacc),
  DEFINE_ISTR(pfadd),
  DEFINE_ISTR(pfcmpeq),
  DEFINE_ISTR(pfcmpge),
  DEFINE_ISTR(pfcmpgt),
  DEFINE_ISTR(pfmax),
  DEFINE_ISTR(pfmin),
  DEFINE_ISTR(pfmul),
  DEFINE_ISTR(pfnacc),
  DEFINE_ISTR(pfpnacc),
  DEFINE_ISTR(pfrcp),
  DEFINE_ISTR(pfrcpit1),
  DEFINE_ISTR(pfrcpit2),
  DEFINE_ISTR(pfrsqit1),
  DEFINE_ISTR(pfrsqrt),
  DEFINE_ISTR(pfsub),
  DEFINE_ISTR(pfsubr),
  DEFINE_ISTR(pi2fd),
  DEFINE_ISTR(pi2fw),
  DEFINE_ISTR(pmulhrw),
  DEFINE_ISTR(pswapd)
END_ISTR

---