radare-common 1:1.5.2-4 / usr / lib / radare / bin / adict

#!/usr/bin/env perl
# intel:  x86ref
# intel:  http://lorca.act.uji.es/e08/ayudas/intel/INST8088.HTM
# arm :   http://infopad.eecs.berkeley.edu/research/pico_radio/Test_Bed/Hardware/Documentation/ARM/ARM_Instruction_Set.pdf
# 

my %ops=(
#xml
	"add" => "add",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"or" => "logical inclusive or",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"adc" => "add with carry",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"sbb" => "integer subtraction with borrow",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"and" => "logical and",
	"es" => "es segment override prefix",
	"daa" => "decimal adjust al after addition",
	"sub" => "subtract",
	"cs" => "cs segment override prefix",
	"das" => "decimal adjust al after subtraction",
	"xor" => "logical exclusive or",
	"ss" => "ss segment override prefix",
	"aaa" => "ascii adjust after addition",
	"cmp" => "compare two operands",
	"ds" => "ds segment override prefix",
	"aas" => "ascii adjust al after subtraction",
	"inc" => "increment by 1",
	"rex" => "access to new 8-bit registers",
	"rex.b" => "extension of r/m field, base field, or opcode reg field",
	"rex.x" => "extension of sib index field",
	"rex.xb" => "rex.x and rex.b combination",
	"rex.r" => "extension of modr/m reg field",
	"rex.rb" => "rex.r and rex.b combination",
	"rex.rx" => "rex.r and rex.x combination",
	"rex.rxb" => "rex.r, rex.x and rex.b combination",
	"dec" => "decrement by 1",
	"rex.w" => "64 bit operand size",
	"rex.wb" => "rex.w and rex.b combination",
	"rex.wx" => "rex.w and rex.x combination",
	"rex.wxb" => "rex.w, rex.x and rex.b combination",
	"rex.wr" => "rex.w and rex.r combination",
	"rex.wrb" => "rex.w, rex.r and rex.b combination",
	"rex.wrx" => "rex.w, rex.r and rex.x combination",
	"rex.wrxb" => "rex.w, rex.r, rex.x and rex.b combination",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"pusha" => "push all general-purpose registers",
	"pushad" => "push all general-purpose registers",
	"popa" => "pop all general-purpose registers",
	"popad" => "pop all general-purpose registers",
	"bound" => "check array index against bounds",
	"arpl" => "adjust rpl field of segment selector",
	"movsxd" => "move with sign-extension",
	"fs" => "fs segment override prefix",
	"gs" => "gs segment override prefix",
	"push" => "push word, doubleword or quadword onto the stack",
	"imul" => "signed multiply",
	"push" => "push word, doubleword or quadword onto the stack",
	"imul" => "signed multiply",
	"ins" => "input from port to string",
	"ins" => "input from port to string",
	"ins" => "input from port to string",
	"outs" => "output string to port",
	"outs" => "output string to port",
	"outs" => "output string to port",
	"jo" => "jump short if overflow (of=1)",
	"jno" => "jump short if not overflow (of=0)",
	"jb" => "jump short if below/not above or equal/carry (cf=1)",
	"jnb" => "jump short if not below/above or equal/not carry (cf=0)",
	"jz" => "jump short if zero/equal (zf=0)",
	"jnz" => "jump short if not zero/not equal (zf=1)",
	"jbe" => "jump short if below or equal/not above (cf=1 and zf=1)",
	"jnbe" => "jump short if not below or equal/above (cf=0 and zf=0)",
	"js" => "jump short if sign (sf=1)",
	"jns" => "jump short if not sign (sf=0)",
	"jp" => "jump short if parity/parity even (pf=1)",
	"jnp" => "jump short if not parity/parity odd",
	"jl" => "jump short if less/not greater (sf!=of)",
	"jnl" => "jump short if not less/greater or equal (sf=of)",
	"jle" => "jump short if less or equal/not greater ((zf=1) or (sf!=of))",
	"jnle" => "jump short if not less nor equal/greater ((zf=0) and (sf=of))",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"add" => "add",
	"or" => "logical inclusive or",
	"adc" => "add with carry",
	"sbb" => "integer subtraction with borrow",
	"and" => "logical and",
	"sub" => "subtract",
	"xor" => "logical exclusive or",
	"cmp" => "compare two operands",
	"test" => "logical compare",
	"xchg" => "exchange register/memory with register",
	"mov" => "move",
	"lea" => "load effective address",
	"mov" => "move",
	"pop" => "pop a value from the stack",
	"xchg" => "exchange register/memory with register",
	"nop" => "no operation",
	"pause" => "spin loop hint",
	"cbw" => "convert byte to word",
	"cwde" => "convert word to doubleword",
	"cbw" => "convert",
	"cwd" => "convert word to doubleword",
	"cdq" => "convert doubleword to quadword",
	"cwd" => "convert",
	"callf" => "call procedure",
	"fwait" => "check pending unmasked floating-point exceptions",
	"pushf" => "push flags register onto the stack",
	"pushfd" => "push eflags register onto the stack",
	"pushf" => "push rflags register onto the stack",
	"popf" => "pop stack into flags register",
	"popfd" => "pop stack into eflags register",
	"popf" => "pop stack into rflags register",
	"sahf" => "store ah into flags",
	"lahf" => "load status flags into ah register",
	"mov" => "move",
	"movs" => "move data from string to string",
	"movs" => "move data from string to string",
	"movs" => "move data from string to string",
	"movs" => "move data from string to string",
	"cmps" => "compare string operands",
	"cmps" => "compare string operands",
	"cmps" => "compare string operands",
	"cmps" => "compare string operands",
	"test" => "logical compare",
	"stos" => "store string",
	"stos" => "store string",
	"stos" => "store string",
	"stos" => "store string",
	"lods" => "load string",
	"lods" => "load string",
	"lods" => "load string",
	"lods" => "load string",
	"scas" => "scan string",
	"scas" => "scan string",
	"scas" => "scan string",
	"scas" => "scan string",
	"mov" => "move",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"retn" => "return from procedure",
	"les" => "load far pointer",
	"lds" => "load far pointer",
	"mov" => "move",
	"enter" => "make stack frame for procedure parameters",
	"leave" => "high level procedure exit",
	"retf" => "return from procedure",
	"int" => "call to interrupt procedure",
	"into" => "call to interrupt procedure",
	"iret" => "interrupt return",
	"iretd" => "interrupt return",
	"iret" => "interrupt return",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"rol" => "rotate",
	"ror" => "rotate",
	"rcl" => "rotate",
	"rcr" => "rotate",
	"shl" => "shift",
	"shr" => "shift",
	"sal" => "shift",
	"sar" => "shift",
	"aam" => "ascii adjust ax after multiply",
	"aad" => "ascii adjust ax before division",
	"salc" => "set al if carry",
	"xlat" => "table look-up translation",
	"fadd" => 	"fmul" => 	"fcom" => "compare real",
	"fcomp" => "compare real and pop",
	"fsub" => 	"fsubr" => 	"fdiv" => 	"fdivr" => 	"fld" => "load floating point value",
	"fxch" => "exchange register contents",
	"fst" => "store floating point value",
	"fnop" => "no operation",
	"fstp" => "store floating point value and pop",
	"fldenv" => "load x87 fpu environment",
	"fchs" => "change sign",
	"fabs" => "absolute value",
	"ftst" => "test",
	"fxam" => "examine",
	"fldcw" => "load x87 fpu control word",
	"fld1" => "load constant +1.0",
	"fldl2t" => "load constant log<sub>2</sub>10",
	"fldl2e" => "load constant log<sub>2</sub>e",
	"fldpi" => "load constant &#960;",
	"fldlg2" => "load constant log<sub>10</sub>2",
	"fldln2" => "load constant log<sub>e</sub>2",
	"fldz" => "load constant +0.0",
	"fnstenv" => "store x87 fpu environment",
	"fstenv" => "store x87 fpu environment",
	"f2xm1" => "compute 2<sup>x</sup>-1",
	"fyl2x" => "compute y &#215; log<sub>2</sub>x and pop",
	"fptan" => "partial tangent",
	"fpatan" => "partial arctangent and pop",
	"fxtract" => "extract exponent and significand",
	"fprem1" => "ieee partial remainder",
	"fdecstp" => "decrement stack-top pointer",
	"fincstp" => "increment stack-top pointer",
	"fnstcw" => "store x87 fpu control word",
	"fstcw" => "store x87 fpu control word",
	"fprem" => "partial remainder (for compatibility with i8087 and i287)",
	"fyl2xp1" => "compute y &#215; log<sub>2</sub>(x+1) and pop",
	"fsqrt" => "square root",
	"fsincos" => "sine and cosine",
	"frndint" => "round to integer",
	"fscale" => "scale",
	"fsin" => "sine",
	"fcos" => "cosine",
	"fiadd" => "add",
	"fcmovb" => "fp conditional move - below (cf=1)",
	"fimul" => "multiply",
	"fcmove" => "fp conditional move - equal (zf=1)",
	"ficom" => "compare integer",
	"fcmovbe" => "fp conditional move - below or equal (cf=1 or zf=1)",
	"ficomp" => "compare integer and pop",
	"fcmovu" => "fp conditional move - unordered (pf=1)",
	"fisub" => "subtract",
	"fisubr" => "reverse subtract",
	"fucompp" => "unordered compare floating point values and pop twice",
	"fidiv" => "divide",
	"fidivr" => "reverse divide",
	"fild" => "load integer",
	"fcmovnb" => "fp conditional move - not below (cf=0)",
	"fisttp" => "store integer with truncation and pop",
	"fcmovne" => "fp conditional move - not equal (zf=0)",
	"fist" => "store integer",
	"fcmovnbe" => "fp conditional move - below or equal (cf=0 and zf=0)",
	"fistp" => "store integer and pop",
	"fcmovnu" => "fp conditional move - not unordered (pf=0)",
	"fneni" => "enable npx interrupt",
	"feni" => "enable npx interrupt",
	"fneni" => "treated as integer nop",
	"fndisi" => "disable npx interrupt",
	"fdisi" => "disable npx interrupt",
	"fndisi" => "treated as integer nop",
	"fnclex" => "clear exceptions",
	"fclex" => "clear exceptions",
	"fninit" => "initialize floating-point unit",
	"finit" => "initialize floating-point unit",
	"fnsetpm" => "set protected mode",
	"fsetpm" => "set protected mode",
	"fnsetpm" => "treated as integer nop",
	"fld" => "load floating point value",
	"fucomi" => "unordered compare floating point values and set eflags",
	"fcomi" => "compare floating point values and set eflags",
	"fstp" => "store floating point value and pop",
	"fadd" => "add",
	"fmul" => "multiply",
	"fcom" => "compare real",
	"fcomp" => "compare real and pop",
	"fsub" => "subtract",
	"fsubr" => "reverse subtract",
	"fsub" => "subtract",
	"fdiv" => "divide",
	"fdivr" => "reverse divide",
	"fdiv" => "divide and pop",
	"fld" => "load floating point value",
	"ffree" => "free floating-point register",
	"fisttp" => "store integer with truncation and pop",
	"fst" => "store floating point value",
	"fstp" => "store floating point value and pop",
	"frstor" => "restore x87 fpu state",
	"fucom" => "unordered compare floating point values",
	"fucomp" => "unordered compare floating point values and pop",
	"fnsave" => "store x87 fpu state",
	"fsave" => "store x87 fpu state",
	"fnstsw" => "store x87 fpu status word",
	"fstsw" => "store x87 fpu status word",
	"fiadd" => "add",
	"faddp" => "add and pop",
	"fimul" => "multiply",
	"fmulp" => "multiply and pop",
	"ficom" => "compare integer",
	"ficomp" => "compare integer and pop",
	"fcompp" => "compare real and pop twice",
	"fisub" => "subtract",
	"fsubrp" => "reverse subtract and pop",
	"fisubr" => "reverse subtract",
	"fsubp" => "subtract and pop",
	"fidiv" => "divide",
	"fdivrp" => "reverse divide and pop",
	"fidivr" => "reverse divide",
	"fdivp" => "divide and pop",
	"fild" => "load integer",
	"fisttp" => "store integer with truncation and pop",
	"fist" => "store integer",
	"fistp" => "store integer and pop",
	"fbld" => "load binary coded decimal",
	"fnstsw" => "store x87 fpu status word",
	"fstsw" => "store x87 fpu status word",
	"fild" => "load integer",
	"fucomip" => "unordered compare floating point values and set eflags and pop",
	"fbstp" => "store bcd integer and pop",
	"fcomip" => "compare floating point values and set eflags and pop",
	"fistp" => "store integer and pop",
	"loopnz" => "decrement count; jump short if count!=0 and zf=0",
	"loopnz" => "decrement count; jump short if count!=0 and zf=0",
	"loopz" => "decrement count; jump short if count!=0 and zf=1",
	"loopz" => "decrement count; jump short if count!=0 and zf=1",
	"loop" => "decrement count; jump short if count!=0",
	"jcxz" => "jump short if ecx register is 0",
	"jrcxz" => "jump short if rcx register is 0",
	"in" => "input from port",
	"out" => "output to port",
	"call" => "call procedure",
	"jmp" => "jump",
	"jmpf" => "jump",
	"jmp" => "jump",
	"in" => "input from port",
	"out" => "output to port",
	"lock" => "assert lock# signal prefix",
	"int1" => "call to interrupt procedure",
	"repnz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"repnz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"repz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"repz" => "repeat string operation prefix",
	"rep" => "repeat string operation prefix",
	"hlt" => "halt",
	"cmc" => "complement carry flag",
	"test" => "logical compare",
	"not" => "one's complement negation",
	"neg" => "two's complement negation",
	"mul" => "unsigned multiply",
	"imul" => "signed multiply",
	"div" => "unsigned divide",
	"idiv" => "signed divide",
	"test" => "logical compare",
	"not" => "one's complement negation",
	"neg" => "two's complement negation",
	"mul" => "unsigned multiply",
	"imul" => "signed multiply",
	"div" => "unsigned divide",
	"idiv" => "signed divide",
	"clc" => "clear carry flag",
	"stc" => "set carry flag",
	"cli" => "clear interrupt flag",
	"sti" => "set interrupt flag",
	"cld" => "clear direction flag",
	"std" => "set direction flag",
	"inc" => "increment by 1",
	"dec" => "decrement by 1",
	"inc" => "increment by 1",
	"dec" => "decrement by 1",
	"call" => "call procedure",
	"callf" => "call procedure",
	"jmp" => "jump",
	"jmpf" => "jump",
	"push" => "push word, doubleword or quadword onto the stack",
	"sldt" => 	"str" => 	"lldt" => "load local descriptor table register",
	"ltr" => "load task register",
	"verr" => "verify a segment for reading",
	"verw" => "verify a segment for writing",
	"jmpe" => "jump to ia-64 instruction set",
	"sgdt" => "store global descriptor table register",
	"vmcall" => "call to vm monitor",
	"vmlaunch" => "launch virtual machine",
	"vmresume" => "resume virtual machine",
	"vmxoff" => "leave vmx operation",
	"sidt" => "store interrupt descriptor table register",
	"monitor" => "set up monitor address",
	"mwait" => "monitor wait",
	"lgdt" => "load global descriptor table register",
	"xgetbv" => "get value of extended control register",
	"xsetbv" => "set extended control register",
	"lidt" => "load interrupt descriptor table register",
	"smsw" => 	"lmsw" => "load machine status word",
	"invlpg" => "invalidate tlb entry",
	"swapgs" => "swap gs base register",
	"rdtscp" => "read time-stamp counter and processor id",
	"lar" => 	"lsl" => 	"loadall" => "load all of the cpu registers",
	"syscall" => "fast system call",
	"clts" => "clear task-switched flag in cr0",
	"loadall" => "load all of the cpu registers",
	"sysret" => "return from fast system call",
	"invd" => "invalidate internal caches",
	"wbinvd" => "write back and invalidate cache",
	"ud2" => "undefined instruction",
	"nop" => "no operation",
	"movups" => "move unaligned packed single-fp values",
	"movss" => "move scalar single-fp values",
	"movupd" => "move unaligned packed double-fp value",
	"movsd" => "move scalar double-fp value",
	"movups" => "move unaligned packed single-fp values",
	"movss" => "move scalar single-fp values",
	"movupd" => "move unaligned packed double-fp values",
	"movsd" => "move scalar double-fp value",
	"movhlps" => "move packed single-fp values high to low",
	"movlps" => "move low packed single-fp values",
	"movlpd" => "move low packed double-fp value",
	"movddup" => "move one double-fp and duplicate",
	"movsldup" => "move packed single-fp low and duplicate",
	"movlps" => "move low packed single-fp values",
	"movlpd" => "move low packed double-fp value",
	"unpcklps" => "unpack and interleave low packed single-fp values",
	"unpcklpd" => "unpack and interleave low packed double-fp values",
	"unpckhps" => "unpack and interleave high packed single-fp values",
	"unpckhpd" => "unpack and interleave high packed double-fp values",
	"movlhps" => "move packed single-fp values low to high",
	"movhps" => "move high packed single-fp values",
	"movhpd" => "move high packed double-fp value",
	"movshdup" => "move packed single-fp high and duplicate",
	"movhps" => "move high packed single-fp values",
	"movhpd" => "move high packed double-fp value",
	"hint_nop" => "hintable nop",
	"prefetchnta" => "prefetch data into caches",
	"prefetcht0" => "prefetch data into caches",
	"prefetcht1" => "prefetch data into caches",
	"prefetcht2" => "prefetch data into caches",
	"hint_nop" => "hintable nop",
	"nop" => "no operation",
	"hint_nop" => "hintable nop",
	"mov" => "move to/from control registers",
	"movaps" => "move aligned packed single-fp values",
	"movapd" => "move aligned packed double-fp values",
	"movaps" => "move aligned packed single-fp values",
	"movapd" => "move aligned packed double-fp values",
	"cvtpi2ps" => "convert packed dw integers to <!--1.11 packed -->single-fp values",
	"cvtsi2ss" => "convert dw integer to scalar single-fp value",
	"cvtpi2pd" => "convert packed dw integers to <!--1.11 packed -->double-fp values",
	"cvtsi2sd" => "convert dw integer to scalar double-fp value",
	"movntps" => "store packed single-fp values using non-temporal hint",
	"movntpd" => "store packed double-fp values using non-temporal hint",
	"cvttps2pi" => "convert with trunc. packed single-fp values to <!--1.11 packed -->dw integers",
	"cvttss2si" => "convert with trunc. scalar single-fp value to dw integer",
	"cvttpd2pi" => "convert with trunc. packed double-fp values to <!--1.11 packed -->dw integers",
	"cvttsd2si" => "conv. with trunc. scalar double-fp value to signed dw int",
	"cvtps2pi" => "convert packed single-fp values to <!--1.11 packed -->dw integers",
	"cvtss2si" => "convert scalar single-fp value to dw integer",
	"cvtpd2pi" => "convert packed double-fp values to <!--1.11 packed -->dw integers",
	"cvtsd2si" => "convert scalar double-fp value to dw integer",
	"ucomiss" => "unordered compare scalar single-fp values and set eflags",
	"ucomisd" => "unordered compare scalar double-fp values and set eflags",
	"comiss" => "compare scalar ordered single-fp values and set eflags",
	"comisd" => "compare scalar ordered double-fp values and set eflags",
	"wrmsr" => "write to model specific register",
	"rdtsc" => "read time-stamp counter",
	"rdmsr" => "read from model specific register",
	"rdpmc" => "read performance-monitoring counters",
	"sysenter" => "fast system call",
	"sysexit" => "fast return from fast system call",
	"getsec" => "getsec leaf functions",
	"pshufb" => "packed shuffle bytes",
	"phaddw" => "packed horizontal add",
	"phaddd" => "packed horizontal add",
	"phaddsw" => "packed horizontal add and saturate",
	"pmaddubsw" => "multiply and add packed signed and unsigned bytes",
	"phsubw" => "packed horizontal subtract",
	"phsubd" => "packed horizontal subtract",
	"phsubsw" => "packed horizontal subtract and saturate",
	"psignb" => "packed sign",
	"psignw" => "packed sign",
	"psignd" => "packed sign",
	"pmulhrsw" => "packed multiply high with round and scale",
	"pblendvb" => "variable blend packed bytes",
	"blendvps" => "variable blend packed single-fp values",
	"blendvpd" => "variable blend packed double-fp values",
	"ptest" => "logical compare",
	"pabsb" => "packed absolute value",
	"pabsw" => "packed absolute value",
	"pabsd" => "packed absolute value",
	"pmovsxbw" => 	"pmovsxbd" => 	"pmovsxbq" => 	"pmovsxwd" => 	"pmovsxwq" => 	"pmovsxdq" => 	"pmuldq" => "multiply packed signed dword integers",
	"pcmpeqq" => "compare packed qword data for equal",
	"movntdqa" => "load double quadword non-temporal aligned hint",
	"packusdw" => "pack with unsigned saturation",
	"pmovzxbw" => 	"pmovzxbd" => 	"pmovzxbq" => 	"pmovzxwd" => 	"pmovzxwq" => 	"pmovzxdq" => 	"pcmpgtq" => "compare packed qword data for greater than",
	"pminsb" => "minimum of packed signed byte integers",
	"pminsd" => "minimum of packed signed dword integers",
	"pminuw" => "minimum of packed unsigned word integers",
	"pminud" => "minimum of packed unsigned dword integers",
	"pmaxsb" => "maximum of packed signed byte integers",
	"pmaxsd" => "maximum of packed signed dword integers",
	"pmaxuw" => "maximum of packed unsigned word integers",
	"pmaxud" => "maximum of packed unsigned dword integers",
	"pmulld" => "multiply packed signed dword integers and store low result",
	"phminposuw" => "packed horizontal word minimum",
	"invept" => "invalidate translations derived from ept",
	"invvpid" => "invalidate translations based on vpid",
	"movbe" => "move data after swapping bytes",
	"crc32" => "accumulate crc32 value",
	"movbe" => "move data after swapping bytes",
	"crc32" => "accumulate crc32 value",
	"roundps" => "round packed single-fp values",
	"roundpd" => "round packed double-fp values",
	"roundss" => "round scalar single-fp values",
	"roundsd" => "round scalar double-fp values",
	"blendps" => "blend packed single-fp values",
	"blendpd" => "blend packed double-fp values",
	"pblendw" => "blend packed words",
	"palignr" => "packed align right",
	"pextrb" => 	"pextrw" => 	"pextrd" => "extract dword/qword",
	"extractps" => "extract packed single-fp value",
	"pinsrb" => 	"insertps" => 	"pinsrd" => "insert dword/qword",
	"dpps" => "dot product of packed single-fp values",
	"dppd" => "dot product of packed double-fp values",
	"mpsadbw" => "compute multiple packed sums of absolute difference",
	"pcmpestrm" => "packed compare explicit length strings, return mask",
	"pcmpestri" => "packed compare explicit length strings, return index",
	"pcmpistrm" => "packed compare implicit length strings, return mask",
	"pcmpistri" => "packed compare implicit length strings, return index",
	"cmovo" => "conditional move - overflow (of=1)",
	"cmovno" => "conditional move - not overflow (of=0)",
	"cmovb" => "conditional move - below/not above or equal/carry (cf=1)",
	"cmovnb" => "conditional move - not below/above or equal/not carry (cf=0)",
	"cmovz" => "conditional move - zero/equal (zf=0)",
	"cmovnz" => "conditional move - not zero/not equal (zf=1)",
	"cmovbe" => "conditional move - below or equal/not above (cf=1 and zf=1)",
	"cmovnbe" => "conditional move - not below or equal/above (cf=0 and zf=0)",
	"cmovs" => "conditional move - sign (sf=1)",
	"cmovns" => "conditional move - not sign (sf=0)",
	"cmovp" => "conditional move - parity/parity even (pf=1)",
	"cmovnp" => "conditional move - not parity/parity odd",
	"cmovl" => "conditional move - less/not greater (sf!=of)",
	"cmovnl" => "conditional move - not less/greater or equal (sf=of)",
	"cmovle" => "conditional move - less or equal/not greater ((zf=1) or (sf!=of))",
	"cmovnle" => "conditional move - not less nor equal/greater ((zf=0) and (sf=of))",
	"movmskps" => "extract packed single-fp sign mask",
	"movmskpd" => "extract packed double-fp sign mask",
	"sqrtps" => "compute square roots of packed single-fp values",
	"sqrtss" => "compute square root of scalar single-fp value",
	"sqrtpd" => "compute square roots of packed double-fp values",
	"sqrtsd" => "compute square root of scalar double-fp value",
	"rsqrtps" => "compute recipr. of square roots of packed single-fp values",
	"rsqrtss" => "compute recipr. of square root of scalar single-fp value",
	"rcpps" => "compute reciprocals of packed single-fp values",
	"rcpss" => "compute reciprocal of scalar single-fp values",
	"andps" => "bitwise logical and of packed single-fp values",
	"andpd" => "bitwise logical and of packed double-fp values",
	"andnps" => "bitwise logical and not of packed single-fp values",
	"andnpd" => "bitwise logical and not of packed double-fp values",
	"orps" => "bitwise logical or of single-fp values",
	"orpd" => "bitwise logical or of double-fp values",
	"xorps" => "bitwise logical xor for single-fp values",
	"xorpd" => "bitwise logical xor for double-fp values",
	"addps" => "add packed single-fp values",
	"addss" => "add scalar single-fp values",
	"addpd" => "add packed double-fp values",
	"addsd" => "add scalar double-fp values",
	"mulps" => "multiply packed single-fp values",
	"mulss" => "multiply scalar single-fp value",
	"mulpd" => "multiply packed double-fp values",
	"mulsd" => "multiply scalar double-fp values",
	"cvtps2pd" => "convert packed single-fp values to <!--1.11 packed -->double-fp values",
	"cvtpd2ps" => "convert packed double-fp values to <!--1.11 packed -->single-fp values",
	"cvtss2sd" => "convert scalar single-fp value to scalar double-fp value ",
	"cvtsd2ss" => "convert scalar double-fp value to scalar single-fp value",
	"cvtdq2ps" => "convert packed dw integers to <!--1.11 packed -->single-fp values",
	"cvtps2dq" => "convert packed single-fp values to <!--1.11 packed -->dw integers",
	"cvttps2dq" => "convert with trunc. packed single-fp values to <!--1.11 packed -->dw integers",
	"subps" => "subtract packed single-fp values",
	"subss" => "subtract scalar single-fp values",
	"subpd" => "subtract packed double-fp values",
	"subsd" => "subtract scalar double-fp values",
	"minps" => "return minimum packed single-fp values",
	"minss" => "return minimum scalar single-fp value",
	"minpd" => "return minimum packed double-fp values",
	"minsd" => "return minimum scalar double-fp value",
	"divps" => "divide packed single-fp values",
	"divss" => "divide scalar single-fp values",
	"divpd" => "divide packed double-fp values",
	"divsd" => "divide scalar double-fp values",
	"maxps" => "return maximum packed single-fp values",
	"maxss" => "return maximum scalar single-fp value",
	"maxpd" => "return maximum packed double-fp values",
	"maxsd" => "return maximum scalar double-fp value",
	"punpcklbw" => "unpack low data",
	"punpcklwd" => "unpack low data",
	"punpckldq" => "unpack low data",
	"packsswb" => "pack with signed saturation",
	"pcmpgtb" => "compare packed signed integers for greater than",
	"pcmpgtw" => "compare packed signed integers for greater than",
	"pcmpgtd" => "compare packed signed integers for greater than",
	"packuswb" => "pack with unsigned saturation",
	"punpckhbw" => "unpack high data",
	"punpckhwd" => "unpack high data",
	"punpckhdq" => "unpack high data",
	"packssdw" => "pack with signed saturation",
	"punpcklqdq" => "unpack low data",
	"punpckhqdq" => "unpack high data",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movdqa" => "move aligned double quadword",
	"movdqu" => "move unaligned double quadword",
	"pshufw" => "shuffle packed words",
	"pshuflw" => "shuffle packed low words",
	"pshufhw" => "shuffle packed high words",
	"pshufd" => "shuffle packed doublewords",
	"psrlw" => "shift packed data right logical",
	"psraw" => "shift packed data right arithmetic",
	"psllw" => "shift packed data left logical",
	"psrld" => "shift double quadword right logical",
	"psrad" => "shift packed data right arithmetic",
	"pslld" => "shift packed data left logical",
	"psrlq" => "shift packed data right logical",
	"psrldq" => "shift double quadword right logical",
	"psllq" => "shift packed data left logical",
	"pslldq" => "shift double quadword left logical",
	"pcmpeqb" => "compare packed data for equal",
	"pcmpeqw" => "compare packed data for equal",
	"pcmpeqd" => "compare packed data for equal",
	"emms" => "empty mmx technology state",
	"vmread" => "read field from virtual-machine control structure",
	"vmwrite" => "write field to virtual-machine control structure",
	"haddpd" => "packed double-fp horizontal add",
	"haddps" => "packed single-fp horizontal add",
	"hsubpd" => "packed double-fp horizontal subtract",
	"hsubps" => "packed single-fp horizontal subtract",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movd" => "move doubleword",
	"movq" => "move doubleword/quadword",
	"movdqa" => "move aligned double quadword",
	"movdqu" => "move unaligned double quadword",
	"jo" => "jump short if overflow (of=1)",
	"jno" => "jump short if not overflow (of=0)",
	"jb" => "jump short if below/not above or equal/carry (cf=1)",
	"jnb" => "jump short if not below/above or equal/not carry (cf=0)",
	"jz" => "jump short if zero/equal (zf=0)",
	"jnz" => "jump short if not zero/not equal (zf=1)",
	"jbe" => "jump short if below or equal/not above (cf=1 and zf=1)",
	"jnbe" => "jump short if not below or equal/above (cf=0 and zf=0)",
	"js" => "jump short if sign (sf=1)",
	"jns" => "jump short if not sign (sf=0)",
	"jp" => "jump short if parity/parity even (pf=1)",
	"jnp" => "jump short if not parity/parity odd",
	"jl" => "jump short if less/not greater (sf!=of)",
	"jnl" => "jump short if not less/greater or equal (sf=of)",
	"jle" => "jump short if less or equal/not greater ((zf=1) or (sf!=of))",
	"jnle" => "jump short if not less nor equal/greater ((zf=0) and (sf=of))",
	"seto" => "set byte on condition - overflow (of=1)",
	"setno" => "set byte on condition - not overflow (of=0)",
	"setb" => "set byte on condition - below/not above or equal/carry (cf=1)",
	"setnb" => "set byte on condition - not below/above or equal/not carry (cf=0)",
	"setz" => "set byte on condition - zero/equal (zf=0)",
	"setnz" => "set byte on condition - not zero/not equal (zf=1)",
	"setbe" => "set byte on condition - below or equal/not above (cf=1 and zf=1)",
	"setnbe" => "set byte on condition - not below or equal/above (cf=0 and zf=0)",
	"sets" => "set byte on condition - sign (sf=1)",
	"setns" => "set byte on condition - not sign (sf=0)",
	"setp" => "set byte on condition - parity/parity even (pf=1)",
	"setnp" => "set byte on condition - not parity/parity odd",
	"setl" => "set byte on condition - less/not greater (sf!=of)",
	"setnl" => "set byte on condition - not less/greater or equal (sf=of)",
	"setle" => "set byte on condition - less or equal/not greater ((zf=1) or (sf!=of))",
	"setnle" => "set byte on condition - not less nor equal/greater ((zf=0) and (sf=of))",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"cpuid" => "cpu identification",
	"bt" => "bit test",
	"shld" => "double precision shift left",
	"push" => "push word, doubleword or quadword onto the stack",
	"pop" => "pop a value from the stack",
	"rsm" => "resume from system management mode",
	"bts" => "bit test and set",
	"shrd" => "double precision shift right",
	"fxsave" => "save x87 fpu, mmx, xmm, and mxcsr state",
	"fxrstor" => "restore x87 fpu, mmx, xmm, and mxcsr state",
	"ldmxcsr" => "load mxcsr register",
	"stmxcsr" => "store mxcsr register state",
	"xsave" => "save processor extended states",
	"lfence" => "load fence",
	"xrstor" => "restore processor extended states",
	"mfence" => "memory fence",
	"sfence" => "store fence",
	"clflush" => "flush cache line",
	"imul" => "signed multiply",
	"cmpxchg" => "compare and exchange",
	"lss" => "load far pointer",
	"btr" => "bit test and reset",
	"lfs" => "load far pointer",
	"lgs" => "load far pointer",
	"movzx" => "move with zero-extend",
	"jmpe" => "jump to ia-64 instruction set",
	"popcnt" => "bit population count",
	"bt" => "bit test",
	"bts" => "bit test and set",
	"btr" => "bit test and reset",
	"btc" => "bit test and complement",
	"bsf" => "bit scan forward",
	"bsr" => "bit scan reverse",
	"movsx" => "move with sign-extension",
	"xadd" => "exchange and add",
	"cmpps" => "compare packed single-fp values",
	"cmpss" => "compare scalar single-fp values",
	"cmppd" => "compare packed double-fp values",
	"cmpsd" => "compare scalar double-fp values",
	"movnti" => "store doubleword using non-temporal hint",
	"pinsrw" => 	"pextrw" => "extract word",
	"shufps" => "shuffle packed single-fp values",
	"shufpd" => "shuffle packed double-fp values",
	"cmpxchg8b" => "compare and exchange bytes",
	"cmpxchg16b" => "compare and exchange bytes",
	"vmptrld" => "load pointer to virtual-machine control structure",
	"vmclear" => "clear virtual-machine control structure",
	"vmxon" => "enter vmx operation",
	"vmptrst" => "store pointer to virtual-machine control structure",
	"bswap" => "byte swap",
	"addsubpd" => "packed double-fp add/subtract",
	"addsubps" => "packed single-fp add/subtract",
	"psrlw" => "shift packed data right logical",
	"psrld" => "shift packed data right logical",
	"psrlq" => "shift packed data right logical",
	"paddq" => "add packed quadword integers",
	"pmullw" => "multiply packed signed integers and store low result",
	"movq" => "move quadword",
	"movq2dq" => "move quadword from mmx technology to xmm register",
	"movdq2q" => "move quadword from xmm to mmx technology register",
	"pmovmskb" => "move byte mask",
	"psubusb" => "subtract packed unsigned integers with unsigned saturation",
	"psubusw" => "subtract packed unsigned integers with unsigned saturation",
	"pminub" => "minimum of packed unsigned byte integers",
	"pand" => "logical and",
	"paddusb" => "add packed unsigned integers with unsigned saturation",
	"paddusw" => "add packed unsigned integers with unsigned saturation",
	"pmaxub" => "maximum of packed unsigned byte integers",
	"pandn" => "logical and not",
	"pavgb" => "average packed integers",
	"psraw" => "shift packed data right arithmetic",
	"psrad" => "shift packed data right arithmetic",
	"pavgw" => "average packed integers",
	"pmulhuw" => "multiply packed unsigned integers and store high result",
	"pmulhw" => "multiply packed signed integers and store high result",
	"cvtpd2dq" => "convert packed double-fp values to <!--1.11 packed -->dw integers",
	"cvttpd2dq" => "convert with trunc. packed double-fp values to <!--1.11 packed -->dw integers",
	"cvtdq2pd" => "convert packed dw integers to <!--1.11 packed -->double-fp values",
	"movntq" => "store of quadword using non-temporal hint",
	"movntdq" => "store double quadword using non-temporal hint",
	"psubsb" => "subtract packed signed integers with signed saturation",
	"psubsw" => "subtract packed signed integers with signed saturation",
	"pminsw" => "minimum of packed signed word integers",
	"por" => "bitwise logical or",
	"paddsb" => "add packed signed integers with signed saturation",
	"paddsw" => "add packed signed integers with signed saturation",
	"pmaxsw" => "maximum of packed signed word integers",
	"pxor" => "logical exclusive or",
	"lddqu" => "load unaligned integer 128 bits",
	"psllw" => "shift packed data left logical",
	"pslld" => "shift packed data left logical",
	"psllq" => "shift packed data left logical",
	"pmuludq" => "multiply packed unsigned dw integers",
	"pmaddwd" => "multiply and add packed integers",
	"psadbw" => "compute sum of absolute differences",
	"maskmovq" => "store selected bytes of quadword",
	"maskmovdqu" => "store selected bytes of double quadword",
	"psubb" => "subtract packed integers",
	"psubw" => "subtract packed integers",
	"psubd" => "subtract packed integers",
	"psubq" => "subtract packed quadword integers",
	"paddb" => "add packed integers",
	"paddw" => "add packed integers",
	"paddd" => "add packed integers",
# intel
	"movzx" => "move dst register size padding with zeroes",
	"sar" => "arithmetic right shift",
	"sal" => "arithmetic left shift",
	"shl" => "logic left shift (0 padding)",
	"shr" => "logic right shift (0 padding)",
	"inc" => "register++",
	"dec" => "register--",
	"xlat"=> "al = [ebx+al]",
	"lahf"=> "AH = SF:ZF:X:AF:X:PF:X:CF",
	"sahf"=> "eflags(SF:ZF:X:AF:X:PF:X:CF) = AX",
	"lea" => "load efective address",
	"rol" => "rotate bits left",
	"ror" => "rotate bits right",
	"rcl" => "rotate bits left (with CF)",
	"rcr" => "rotate bits right (with CF)",
	"add" => "adds src and dst, stores result on dst",
	"and" => "binary and operation between src and dst, stores result on dst",
	"xor" => "exclusive or x^=y (x86) or x = y ^ z (arm)",
	"sub" => "substract src and dst, stores result on dst",
	"jmp" => "changes eip to another position",
	"call"=> "calls a subroutine, pushes eip into stack (esp)",
	"push"=> "pushes the argument to stack (esp)",
	"pop" => "pops last element of stack and stores the result in argument",
	"mov" => "moves data from src to dst",
	"nop" => "does nothing (nop [eax] (0F 1X XX) performs a memory read and nops)",
	"movsb"=>"ES:[edi] = (byte)DS:[esi] (esi++, edi++)",
	"movsw"=>"ES:[edi] = (word)DS:[esi] (esi+=2, edi+=2)",
	"movsd"=>"ES:[edi] = (dword)DS:[esi] (esi+=4, edi+=4)",
	"lodsb"=>"al = (byte)DS:[esi] (esi++)",
	"lodsw"=>"ax = (word)DS:[esi] (esi+=2)",
	"stosb"=>"ES:[edi] = al (edi++)",
	"cmpsb"=>"cmp DS:[SI], ES:[edi] (esi++, edi++)",
	"scasb"=>"cmp al, ES:[edi++]",
	"scasw"=>"cmp ax, ES:[edi+=2]",
	"rep" => "repeats next instruction ECX times",
	"ret" => "return from subroutine. pop 4 bytes from esp and jump there.",
	"enter" => "alias for push ebp mov ebp, esp",
	"leave" => "one byte alias for mov esp, ebp ; pop ebp",
	"clc" => "eflags[CF] = 0",
	"stc" => "eflags[CF] = 1",
	"cld" => "elfags[DF] = 0",
	"std" => "elfags[DF] = 1",
	"cli" => "elfags[IF] = 0",
	"sti" => "elfags[IF] = 1",
	"hlt" => "stop process until external interrupt received",
	"wait"=> "stop process execution until TEST pin activated",
	"lock" => "instruction prefix to setup the LOCK pin",
	"retn" =>"ret* to the same code segment",
	"retf" =>"ret* to other code segment",
	"test" =>"set eflags after comparing two registers (AF, CF, OF, PF, SF, ZF)",
	"jcxz" =>"Jump if ecx = 0",
	"loop" =>"if (ecx-- == 0) jmp ..",
	"loopz"=>"if (ecx-- == 0 && eflags[ZF] == 1) jmp ..",
	"into" =>"interrupt if eflags[OF]=1",
	"iret" => "return from interrupt",
# i387
	"fdiv" => "floating divide",
	"fdivp" => "floating divide and pop",
	"fdivr" => "floating divide reversed",
	"fdivrp" => "floating divide reversed and pop",
	"fidiv" => "integer divide",
	"fidivr" => "integer divide reserved",
	"feni" => "enable interrupts",
	"fneni" => "enable interrupts, no wait",
	"ffree" => "free register",
	"fiadd" => "integer add",
	"ficom" => "integer compare",
	"ficomp" => "integer compare and pop",
	"fild" => "load integer",
	"fimul" => "integer multiply",
	"fabs" => "absolute value",
	"fadd" => "floating point add",
	"faddp" => "floating point add and pop",
	"fbld" => "load bcd",
	"fbstp" => "store bcd and pop",
	"fchs" => "change sign",
	"fclex" => "clear exceptions",
	"fnclex" => "clear exceptions, no wait",
	"fcom" => "floating point compare",
	"fcomp" => "floating point compare and pop",
	"fcompp" => "floating point compare and pop twice",
	"fcos" => "floating point cosine",
	"finit" => "initialize fpu",
	"fninit" => "initialize fpu, no wait",
	"fist" => "store integer",
	"fistp" => "store integer and pop",
	"fisub" => "integer substract",
	"fisubr" => "integer susbtract reversed",
	"fld" => "floatint point load",
	"fldz" => "load constant onto stack 0.0f",
	"fld1" => "load constant onto stack 1.0f",
	"fldl2e" => "load constant onto stack, logarithm base 2 (e)",
	"fldl2t" => "load constant onto stack, logarithm base 2 (10)",
	"fldlg2" => "load constant onto stack, logarithm base 10 (2)",
	"fldln2" => "load constant onto stack, natural logarithm (2)",
	"fldpi" => "load constant onto stack, 3.14159..",
	"fldcw" => "load control word",
	"fldenv" => "load environment state",
	"fmul" => "floating point multiply",
	"fmulp" => "floating point multiply and pop",
	"fnop" => "no operation",
	"fincstp" => "increment floating point stack pointer (%foo)",
	"fdecstp" => "decrement floating point stack pointer (%foo)",
	"fdisi" => "disable interrupts",
	"fndisi" => "disable interrupts, no wait",
# ARM
	"b"   => "branches the program counter to dst (pc aka r15)",
	"bl"  => "branches and link, similar to call in i386, set lr(r14) = pc, changes pc (r15) )",
	"bx"  => "branches and exchanges cpu mode to 16 bits (thumb mode)",
	"bxj" => "branches and exchanges cpu mode to Jazzele (jumps to a bytecode vector)",
	"beq" => "branches if equal (see 'b')",
	"bne" => "branches if not equal (see 'b')",
	"cmp" => "compares two registers",
	"str" => "stores (TODO)",
	"ldr" => "load to register(TODO)",
	"ldf" => "armfpu: load float value pointed by reg+(offset): ldf f0, [r0,#off]",
	"stf" => "armfpu: store float value pointed by reg+(offset): ldf [r0,#off]",
	"flt" => "armfpu: convert int to float: flt ",
	"wfs" => "armfpu: write fp status register. wfs r0",
# PPC
# r0 = call arg, return value
# r1 = stack pointer
# r2 = rtoc (register table of contents) (like a5 68k reg, not used, global to func (if i dont call a func))
# r3-r10 - general purpose registers
	"bgt" => "Branch if greater or equal (PPC: bgt CRn, addr, ARM: bgt addr)",
	"sc" => "Syscall - see svc for supervisor call on powerpc",
	"dbnz" => "Decrement counter and branch if not zero",
	"dbz" => "Decrement counter and branch if zero",
	"li"  => "powerpc: load integer into register; li r3, 1",
	"mtctr" => "powerpc: preload count register (???)",
	"addic" => "powerpc: add integer to register with carry: addic r3, r3, 1",
	"lwz" => "load word and zero (32b); lwzu   r3,4(r4)      ; r4 = r4 + 4 ; r3 = *(r4)",
	"lhz" => "load half word and zero (16b)",
	"lbz" => "load byte and zero (8b)",
	"lbzu" => "powerpc: lbzu     r8,1(r4)     ;  r8 = *(++p2)",
	"cmpw" => "compare word; cmpw CR0, r0, r1 (signed)",
	"cmplw" => "compare logical word; cmplwi CR0, r0, 33(unsigned)",
	"cmplwi" => "compare logical word against int; cmplwi CR0, r0, 33(unsigned)",
	"bctr" => "Branch to counter register",
	"bcctr" => "Conditional branch to counter register",
	"svc" => "The svc instruction generates a supervisor call interrupt and places
bits 16-31 of the svc instruction into bits 0-15 of the
Count Register (CR) and bits 16-31 of the Machine State
Register (MSR) into bits 16-31 of the CR.

Consider the following when using the svc instruction:

    * If the SVC Absolute bit (SA) is set to 0, the instruction fetch
      and execution continues at one of the 128 offsets, b'1'|| LEV ||b'00000',
      to the base effective address (EA) indicated by the setting of the IP bit
      of the MSR. FL1 and FL2 fields could be used for passing data to the SVC
      routine but are ignored by hardware.

    * If the SVC Absolute bit (SA) is set to 1, then instruction fetch and
      execution continues at the offset, x'1FE0', to the base EA indicated by
      the setting of the IP bit of the MSR.

    * If the Link bit (LK) is set to 1, the EA of the instruction following the
      svc instruction is placed in the Link Register.

    Notes:
      1. To ensure correct operation, an svc instruction must be preceded by an
         unconditional branch or a CR instruction. If a useful instruction cannot
         be scheduled as specified, use a no-op version of the cror instruction
         with the following syntax:

       cror BT,BA,BB      No-op when BT = BA = BB

      2. The svc instruction has the same op code as the sc (System Call) instruction."
);

if ( $ARGV[0] eq "" ) {
	print "Usage: rsc adict [-l] [opcode] ; support java, intel, arm and powerpc opcodes\n";
	print "  example: $ rsc adict 'nop'\n";
	exit 0;
}

if ($ops{$ARGV[0]}) {
	print $ARGV[0]."   ".$ops{$ARGV[0]}."\n";
} else {
	print "unknown opcode\n";
}