Newer
Older
case STARS_NN_psrlq: // Packed Shift Right Logical (Qword)
case STARS_NN_psubb: // Packed Subtract Byte
case STARS_NN_psubw: // Packed Subtract Word
case STARS_NN_psubd: // Packed Subtract Dword
case STARS_NN_psubsb: // Packed Subtract with Saturation (Byte)
case STARS_NN_psubsw: // Packed Subtract with Saturation (Word)
case STARS_NN_psubusb: // Packed Subtract Unsigned with Saturation (Byte)
case STARS_NN_psubusw: // Packed Subtract Unsigned with Saturation (Word)
case STARS_NN_punpckhbw: // Unpack High Packed Data (Byte->Word)
case STARS_NN_punpckhwd: // Unpack High Packed Data (Word->Dword)
case STARS_NN_punpckhdq: // Unpack High Packed Data (Dword->Qword)
case STARS_NN_punpcklbw: // Unpack Low Packed Data (Byte->Word)
case STARS_NN_punpcklwd: // Unpack Low Packed Data (Word->Dword)
case STARS_NN_punpckldq: // Unpack Low Packed Data (Dword->Qword)
case STARS_NN_pxor: // Bitwise Logical Exclusive Or
SMP_fprintf(OutFile, "ERROR");
break;
//
// Undocumented Deschutes processor instructions
//
case STARS_NN_fxsave: // Fast save FP context
case STARS_NN_fxrstor: // Fast restore FP context
SMP_fprintf(OutFile, "ERROR");
break;
// Pentium II instructions
case STARS_NN_sysenter: // Fast Transition to System Call Entry Point
case STARS_NN_sysexit: // Fast Transition from System Call Entry Point
SMP_fprintf(OutFile, "ERROR");
break;
// 3DNow! instructions
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
case STARS_NN_pavgusb: // Packed 8-bit Unsigned Integer Averaging
case STARS_NN_pfadd: // Packed Floating-Point Addition
case STARS_NN_pfsub: // Packed Floating-Point Subtraction
case STARS_NN_pfsubr: // Packed Floating-Point Reverse Subtraction
case STARS_NN_pfacc: // Packed Floating-Point Accumulate
case STARS_NN_pfcmpge: // Packed Floating-Point Comparison, Greater or Equal
case STARS_NN_pfcmpgt: // Packed Floating-Point Comparison, Greater
case STARS_NN_pfcmpeq: // Packed Floating-Point Comparison, Equal
case STARS_NN_pfmin: // Packed Floating-Point Minimum
case STARS_NN_pfmax: // Packed Floating-Point Maximum
case STARS_NN_pi2fd: // Packed 32-bit Integer to Floating-Point
case STARS_NN_pf2id: // Packed Floating-Point to 32-bit Integer
case STARS_NN_pfrcp: // Packed Floating-Point Reciprocal Approximation
case STARS_NN_pfrsqrt: // Packed Floating-Point Reciprocal Square Root Approximation
case STARS_NN_pfmul: // Packed Floating-Point Multiplication
case STARS_NN_pfrcpit1: // Packed Floating-Point Reciprocal First Iteration Step
case STARS_NN_pfrsqit1: // Packed Floating-Point Reciprocal Square Root First Iteration Step
case STARS_NN_pfrcpit2: // Packed Floating-Point Reciprocal Second Iteration Step
case STARS_NN_pmulhrw: // Packed Floating-Point 16-bit Integer Multiply with rounding
case STARS_NN_femms: // Faster entry/exit of the MMX or floating-point state
case STARS_NN_prefetch: // Prefetch at least a 32-byte line into L1 data cache
case STARS_NN_prefetchw: // Prefetch processor cache line into L1 data cache (mark as modified)
SMP_fprintf(OutFile, "ERROR");
break;
// Pentium III instructions
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
case STARS_NN_addps: // Packed Single-FP Add
case STARS_NN_addss: // Scalar Single-FP Add
case STARS_NN_andnps: // Bitwise Logical And Not for Single-FP
case STARS_NN_andps: // Bitwise Logical And for Single-FP
case STARS_NN_cmpps: // Packed Single-FP Compare
case STARS_NN_cmpss: // Scalar Single-FP Compare
case STARS_NN_comiss: // Scalar Ordered Single-FP Compare and Set EFLAGS
case STARS_NN_cvtpi2ps: // Packed signed INT32 to Packed Single-FP conversion
case STARS_NN_cvtps2pi: // Packed Single-FP to Packed INT32 conversion
case STARS_NN_cvtsi2ss: // Scalar signed INT32 to Single-FP conversion
case STARS_NN_cvtss2si: // Scalar Single-FP to signed INT32 conversion
case STARS_NN_cvttps2pi: // Packed Single-FP to Packed INT32 conversion (truncate)
case STARS_NN_cvttss2si: // Scalar Single-FP to signed INT32 conversion (truncate)
case STARS_NN_divps: // Packed Single-FP Divide
case STARS_NN_divss: // Scalar Single-FP Divide
case STARS_NN_ldmxcsr: // Load Streaming SIMD Extensions Technology Control/Status Register
case STARS_NN_maxps: // Packed Single-FP Maximum
case STARS_NN_maxss: // Scalar Single-FP Maximum
case STARS_NN_minps: // Packed Single-FP Minimum
case STARS_NN_minss: // Scalar Single-FP Minimum
case STARS_NN_movaps: // Move Aligned Four Packed Single-FP
case STARS_NN_movhlps: // Move High to Low Packed Single-FP
case STARS_NN_movhps: // Move High Packed Single-FP
case STARS_NN_movlhps: // Move Low to High Packed Single-FP
case STARS_NN_movlps: // Move Low Packed Single-FP
case STARS_NN_movmskps: // Move Mask to Register
case STARS_NN_movss: // Move Scalar Single-FP
case STARS_NN_movups: // Move Unaligned Four Packed Single-FP
case STARS_NN_mulps: // Packed Single-FP Multiply
case STARS_NN_mulss: // Scalar Single-FP Multiply
case STARS_NN_orps: // Bitwise Logical OR for Single-FP Data
case STARS_NN_rcpps: // Packed Single-FP Reciprocal
case STARS_NN_rcpss: // Scalar Single-FP Reciprocal
case STARS_NN_rsqrtps: // Packed Single-FP Square Root Reciprocal
case STARS_NN_rsqrtss: // Scalar Single-FP Square Root Reciprocal
case STARS_NN_shufps: // Shuffle Single-FP
case STARS_NN_sqrtps: // Packed Single-FP Square Root
case STARS_NN_sqrtss: // Scalar Single-FP Square Root
case STARS_NN_stmxcsr: // Store Streaming SIMD Extensions Technology Control/Status Register
case STARS_NN_subps: // Packed Single-FP Subtract
case STARS_NN_subss: // Scalar Single-FP Subtract
case STARS_NN_ucomiss: // Scalar Unordered Single-FP Compare and Set EFLAGS
case STARS_NN_unpckhps: // Unpack High Packed Single-FP Data
case STARS_NN_unpcklps: // Unpack Low Packed Single-FP Data
case STARS_NN_xorps: // Bitwise Logical XOR for Single-FP Data
case STARS_NN_pavgb: // Packed Average (Byte)
case STARS_NN_pavgw: // Packed Average (Word)
case STARS_NN_pextrw: // Extract Word
case STARS_NN_pinsrw: // Insert Word
case STARS_NN_pmaxsw: // Packed Signed Integer Word Maximum
case STARS_NN_pmaxub: // Packed Unsigned Integer Byte Maximum
case STARS_NN_pminsw: // Packed Signed Integer Word Minimum
case STARS_NN_pminub: // Packed Unsigned Integer Byte Minimum
case STARS_NN_pmovmskb: // Move Byte Mask to Integer
case STARS_NN_pmulhuw: // Packed Multiply High Unsigned
case STARS_NN_psadbw: // Packed Sum of Absolute Differences
case STARS_NN_pshufw: // Packed Shuffle Word
case STARS_NN_maskmovq: // Byte Mask write
case STARS_NN_movntps: // Move Aligned Four Packed Single-FP Non Temporal
case STARS_NN_movntq: // Move 64 Bits Non Temporal
case STARS_NN_prefetcht0: // Prefetch to all cache levels
case STARS_NN_prefetcht1: // Prefetch to all cache levels
case STARS_NN_prefetcht2: // Prefetch to L2 cache
case STARS_NN_prefetchnta: // Prefetch to L1 cache
case STARS_NN_sfence: // Store Fence
SMP_fprintf(OutFile, "ERROR");
break;
// Pentium III Pseudo instructions
case STARS_NN_cmpeqps: // Packed Single-FP Compare EQ
case STARS_NN_cmpltps: // Packed Single-FP Compare LT
case STARS_NN_cmpleps: // Packed Single-FP Compare LE
case STARS_NN_cmpunordps: // Packed Single-FP Compare UNORD
case STARS_NN_cmpneqps: // Packed Single-FP Compare NOT EQ
case STARS_NN_cmpnltps: // Packed Single-FP Compare NOT LT
case STARS_NN_cmpnleps: // Packed Single-FP Compare NOT LE
case STARS_NN_cmpordps: // Packed Single-FP Compare ORDERED
case STARS_NN_cmpeqss: // Scalar Single-FP Compare EQ
case STARS_NN_cmpltss: // Scalar Single-FP Compare LT
case STARS_NN_cmpless: // Scalar Single-FP Compare LE
case STARS_NN_cmpunordss: // Scalar Single-FP Compare UNORD
case STARS_NN_cmpneqss: // Scalar Single-FP Compare NOT EQ
case STARS_NN_cmpnltss: // Scalar Single-FP Compare NOT LT
case STARS_NN_cmpnless: // Scalar Single-FP Compare NOT LE
case STARS_NN_cmpordss: // Scalar Single-FP Compare ORDERED
SMP_fprintf(OutFile, "ERROR");
break;
// AMD K7 instructions
case STARS_NN_pf2iw: // Packed Floating-Point to Integer with Sign Extend
case STARS_NN_pfnacc: // Packed Floating-Point Negative Accumulate
case STARS_NN_pfpnacc: // Packed Floating-Point Mixed Positive-Negative Accumulate
case STARS_NN_pi2fw: // Packed 16-bit Integer to Floating-Point
case STARS_NN_pswapd: // Packed Swap Double Word
SMP_fprintf(OutFile, "ERROR");
break;
// Undocumented FP instructions (thanks to norbert.juffa@adm.com)
case STARS_NN_fstp1: // Alias of Store Real and Pop
case STARS_NN_fcom2: // Alias of Compare Real
case STARS_NN_fcomp3: // Alias of Compare Real and Pop
case STARS_NN_fxch4: // Alias of Exchange Registers
case STARS_NN_fcomp5: // Alias of Compare Real and Pop
case STARS_NN_ffreep: // Free Register and Pop
case STARS_NN_fxch7: // Alias of Exchange Registers
case STARS_NN_fstp8: // Alias of Store Real and Pop
case STARS_NN_fstp9: // Alias of Store Real and Pop
SMP_fprintf(OutFile, "ERROR");
break;
// Pentium 4 instructions
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
case STARS_NN_addpd: // Add Packed Double-Precision Floating-Point Values
case STARS_NN_addsd: // Add Scalar Double-Precision Floating-Point Values
case STARS_NN_andnpd: // Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values
case STARS_NN_andpd: // Bitwise Logical AND of Packed Double-Precision Floating-Point Values
case STARS_NN_clflush: // Flush Cache Line
case STARS_NN_cmppd: // Compare Packed Double-Precision Floating-Point Values
case STARS_NN_cmpsd: // Compare Scalar Double-Precision Floating-Point Values
case STARS_NN_comisd: // Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
case STARS_NN_cvtdq2pd: // Convert Packed Doubleword Integers to Packed Single-Precision Floating-Point Values
case STARS_NN_cvtdq2ps: // Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values
case STARS_NN_cvtpd2dq: // Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_cvtpd2pi: // Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_cvtpd2ps: // Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values
case STARS_NN_cvtpi2pd: // Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values
case STARS_NN_cvtps2dq: // Convert Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_cvtps2pd: // Convert Packed Single-Precision Floating-Point Values to Packed Double-Precision Floating-Point Values
case STARS_NN_cvtsd2si: // Convert Scalar Double-Precision Floating-Point Value to Doubleword Integer
case STARS_NN_cvtsd2ss: // Convert Scalar Double-Precision Floating-Point Value to Scalar Single-Precision Floating-Point Value
case STARS_NN_cvtsi2sd: // Convert Doubleword Integer to Scalar Double-Precision Floating-Point Value
case STARS_NN_cvtss2sd: // Convert Scalar Single-Precision Floating-Point Value to Scalar Double-Precision Floating-Point Value
case STARS_NN_cvttpd2dq: // Convert With Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_cvttpd2pi: // Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_cvttps2dq: // Convert With Truncation Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_cvttsd2si: // Convert with Truncation Scalar Double-Precision Floating-Point Value to Doubleword Integer
case STARS_NN_divpd: // Divide Packed Double-Precision Floating-Point Values
case STARS_NN_divsd: // Divide Scalar Double-Precision Floating-Point Values
case STARS_NN_lfence: // Load Fence
case STARS_NN_maskmovdqu: // Store Selected Bytes of Double Quadword
case STARS_NN_maxpd: // Return Maximum Packed Double-Precision Floating-Point Values
case STARS_NN_maxsd: // Return Maximum Scalar Double-Precision Floating-Point Value
case STARS_NN_mfence: // Memory Fence
case STARS_NN_minpd: // Return Minimum Packed Double-Precision Floating-Point Values
case STARS_NN_minsd: // Return Minimum Scalar Double-Precision Floating-Point Value
case STARS_NN_movapd: // Move Aligned Packed Double-Precision Floating-Point Values
case STARS_NN_movdq2q: // Move Quadword from XMM to MMX Register
case STARS_NN_movdqa: // Move Aligned Double Quadword
case STARS_NN_movdqu: // Move Unaligned Double Quadword
case STARS_NN_movhpd: // Move High Packed Double-Precision Floating-Point Values
case STARS_NN_movlpd: // Move Low Packed Double-Precision Floating-Point Values
case STARS_NN_movmskpd: // Extract Packed Double-Precision Floating-Point Sign Mask
case STARS_NN_movntdq: // Store Double Quadword Using Non-Temporal Hint
case STARS_NN_movnti: // Store Doubleword Using Non-Temporal Hint
case STARS_NN_movntpd: // Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint
case STARS_NN_movq2dq: // Move Quadword from MMX to XMM Register
case STARS_NN_movsd: // Move Scalar Double-Precision Floating-Point Values
case STARS_NN_movupd: // Move Unaligned Packed Double-Precision Floating-Point Values
case STARS_NN_mulpd: // Multiply Packed Double-Precision Floating-Point Values
case STARS_NN_mulsd: // Multiply Scalar Double-Precision Floating-Point Values
case STARS_NN_orpd: // Bitwise Logical OR of Double-Precision Floating-Point Values
case STARS_NN_paddq: // Add Packed Quadword Integers
case STARS_NN_pause: // Spin Loop Hint
case STARS_NN_pmuludq: // Multiply Packed Unsigned Doubleword Integers
case STARS_NN_pshufd: // Shuffle Packed Doublewords
case STARS_NN_pshufhw: // Shuffle Packed High Words
case STARS_NN_pshuflw: // Shuffle Packed Low Words
case STARS_NN_pslldq: // Shift Double Quadword Left Logical
case STARS_NN_psrldq: // Shift Double Quadword Right Logical
case STARS_NN_psubq: // Subtract Packed Quadword Integers
case STARS_NN_punpckhqdq: // Unpack High Data
case STARS_NN_punpcklqdq: // Unpack Low Data
case STARS_NN_shufpd: // Shuffle Packed Double-Precision Floating-Point Values
case STARS_NN_sqrtpd: // Compute Square Roots of Packed Double-Precision Floating-Point Values
case STARS_NN_sqrtsd: // Compute Square Rootof Scalar Double-Precision Floating-Point Value
case STARS_NN_subpd: // Subtract Packed Double-Precision Floating-Point Values
case STARS_NN_subsd: // Subtract Scalar Double-Precision Floating-Point Values
case STARS_NN_ucomisd: // Unordered Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
case STARS_NN_unpckhpd: // Unpack and Interleave High Packed Double-Precision Floating-Point Values
case STARS_NN_unpcklpd: // Unpack and Interleave Low Packed Double-Precision Floating-Point Values
case STARS_NN_xorpd: // Bitwise Logical OR of Double-Precision Floating-Point Values
SMP_fprintf(OutFile, "ERROR");
break;
// AMD syscall/sysret instructions
case STARS_NN_syscall: // Low latency system call
case STARS_NN_sysret: // Return from system call
SMP_fprintf(OutFile, "ERROR");
break;
// AMD64 instructions
case STARS_NN_swapgs: // Exchange GS base with KernelGSBase MSR
SMP_fprintf(OutFile, "ERROR");
break;
// New Pentium instructions (SSE3)
case STARS_NN_movddup: // Move One Double-FP and Duplicate
case STARS_NN_movshdup: // Move Packed Single-FP High and Duplicate
case STARS_NN_movsldup: // Move Packed Single-FP Low and Duplicate
SMP_fprintf(OutFile, "ERROR");
break;
// Missing AMD64 instructions
case STARS_NN_movsxd: // Move with Sign-Extend Doubleword
case STARS_NN_cmpxchg16b: // Compare and Exchange 16 Bytes
SMP_fprintf(OutFile, "ERROR");
break;
// SSE3 instructions
case STARS_NN_addsubpd: // Add /Sub packed DP FP numbers
case STARS_NN_addsubps: // Add /Sub packed SP FP numbers
case STARS_NN_haddpd: // Add horizontally packed DP FP numbers
case STARS_NN_haddps: // Add horizontally packed SP FP numbers
case STARS_NN_hsubpd: // Sub horizontally packed DP FP numbers
case STARS_NN_hsubps: // Sub horizontally packed SP FP numbers
case STARS_NN_monitor: // Set up a linear address range to be monitored by hardware
case STARS_NN_mwait: // Wait until write-back store performed within the range specified by the MONITOR instruction
case STARS_NN_fisttp: // Store ST in intXX (chop) and pop
case STARS_NN_lddqu: // Load unaligned integer 128-bit
SMP_fprintf(OutFile, "ERROR");
break;
// SSSE3 instructions
case STARS_NN_psignb: // Packed SIGN Byte
case STARS_NN_psignw: // Packed SIGN Word
case STARS_NN_psignd: // Packed SIGN Doubleword
case STARS_NN_pshufb: // Packed Shuffle Bytes
case STARS_NN_pmulhrsw: // Packed Multiply High with Round and Scale
case STARS_NN_pmaddubsw: // Multiply and Add Packed Signed and Unsigned Bytes
case STARS_NN_phsubsw: // Packed Horizontal Subtract and Saturate
case STARS_NN_phaddsw: // Packed Horizontal Add and Saturate
case STARS_NN_phaddw: // Packed Horizontal Add Word
case STARS_NN_phaddd: // Packed Horizontal Add Doubleword
case STARS_NN_phsubw: // Packed Horizontal Subtract Word
case STARS_NN_phsubd: // Packed Horizontal Subtract Doubleword
case STARS_NN_palignr: // Packed Align Right
case STARS_NN_pabsb: // Packed Absolute Value Byte
case STARS_NN_pabsw: // Packed Absolute Value Word
case STARS_NN_pabsd: // Packed Absolute Value Doubleword
SMP_fprintf(OutFile, "ERROR");
break;
// VMX instructions
case STARS_NN_vmcall: // Call to VM Monitor
case STARS_NN_vmclear: // Clear Virtual Machine Control Structure
case STARS_NN_vmlaunch: // Launch Virtual Machine
case STARS_NN_vmresume: // Resume Virtual Machine
case STARS_NN_vmptrld: // Load Pointer to Virtual Machine Control Structure
case STARS_NN_vmptrst: // Store Pointer to Virtual Machine Control Structure
case STARS_NN_vmread: // Read Field from Virtual Machine Control Structure
case STARS_NN_vmwrite: // Write Field from Virtual Machine Control Structure
case STARS_NN_vmxoff: // Leave VMX Operation
case STARS_NN_vmxon: // Enter VMX Operation
SMP_fprintf(OutFile, "ERROR");
break;
// Undefined Instruction
case STARS_NN_ud2: // Undefined Instruction
SMP_fprintf(OutFile, "ERROR");
break;
// Added with x86-64
case STARS_NN_rdtscp: // Read Time-Stamp Counter and Processor ID
SMP_fprintf(OutFile, "ERROR");
break;
// Geode LX 3DNow! extensions
case STARS_NN_pfrcpv: // Reciprocal Approximation for a Pair of 32-bit Floats
case STARS_NN_pfrsqrtv: // Reciprocal Square Root Approximation for a Pair of 32-bit Floats
SMP_fprintf(OutFile, "ERROR");
break;
// SSE2 pseudoinstructions
case STARS_NN_cmpeqpd: // Packed Double-FP Compare EQ
case STARS_NN_cmpltpd: // Packed Double-FP Compare LT
case STARS_NN_cmplepd: // Packed Double-FP Compare LE
case STARS_NN_cmpunordpd: // Packed Double-FP Compare UNORD
case STARS_NN_cmpneqpd: // Packed Double-FP Compare NOT EQ
case STARS_NN_cmpnltpd: // Packed Double-FP Compare NOT LT
case STARS_NN_cmpnlepd: // Packed Double-FP Compare NOT LE
case STARS_NN_cmpordpd: // Packed Double-FP Compare ORDERED
case STARS_NN_cmpeqsd: // Scalar Double-FP Compare EQ
case STARS_NN_cmpltsd: // Scalar Double-FP Compare LT
case STARS_NN_cmplesd: // Scalar Double-FP Compare LE
case STARS_NN_cmpunordsd: // Scalar Double-FP Compare UNORD
case STARS_NN_cmpneqsd: // Scalar Double-FP Compare NOT EQ
case STARS_NN_cmpnltsd: // Scalar Double-FP Compare NOT LT
case STARS_NN_cmpnlesd: // Scalar Double-FP Compare NOT LE
case STARS_NN_cmpordsd: // Scalar Double-FP Compare ORDERED
SMP_fprintf(OutFile, "ERROR");
break;
// SSSE4.1 instructions
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
case STARS_NN_blendpd: // Blend Packed Double Precision Floating-Point Values
case STARS_NN_blendps: // Blend Packed Single Precision Floating-Point Values
case STARS_NN_blendvpd: // Variable Blend Packed Double Precision Floating-Point Values
case STARS_NN_blendvps: // Variable Blend Packed Single Precision Floating-Point Values
case STARS_NN_dppd: // Dot Product of Packed Double Precision Floating-Point Values
case STARS_NN_dpps: // Dot Product of Packed Single Precision Floating-Point Values
case STARS_NN_extractps: // Extract Packed Single Precision Floating-Point Value
case STARS_NN_insertps: // Insert Packed Single Precision Floating-Point Value
case STARS_NN_movntdqa: // Load Double Quadword Non-Temporal Aligned Hint
case STARS_NN_mpsadbw: // Compute Multiple Packed Sums of Absolute Difference
case STARS_NN_packusdw: // Pack with Unsigned Saturation
case STARS_NN_pblendvb: // Variable Blend Packed Bytes
case STARS_NN_pblendw: // Blend Packed Words
case STARS_NN_pcmpeqq: // Compare Packed Qword Data for Equal
case STARS_NN_pextrb: // Extract Byte
case STARS_NN_pextrd: // Extract Dword
case STARS_NN_pextrq: // Extract Qword
case STARS_NN_phminposuw: // Packed Horizontal Word Minimum
case STARS_NN_pinsrb: // Insert Byte
case STARS_NN_pinsrd: // Insert Dword
case STARS_NN_pinsrq: // Insert Qword
case STARS_NN_pmaxsb: // Maximum of Packed Signed Byte Integers
case STARS_NN_pmaxsd: // Maximum of Packed Signed Dword Integers
case STARS_NN_pmaxud: // Maximum of Packed Unsigned Dword Integers
case STARS_NN_pmaxuw: // Maximum of Packed Word Integers
case STARS_NN_pminsb: // Minimum of Packed Signed Byte Integers
case STARS_NN_pminsd: // Minimum of Packed Signed Dword Integers
case STARS_NN_pminud: // Minimum of Packed Unsigned Dword Integers
case STARS_NN_pminuw: // Minimum of Packed Word Integers
case STARS_NN_pmovsxbw: // Packed Move with Sign Extend
case STARS_NN_pmovsxbd: // Packed Move with Sign Extend
case STARS_NN_pmovsxbq: // Packed Move with Sign Extend
case STARS_NN_pmovsxwd: // Packed Move with Sign Extend
case STARS_NN_pmovsxwq: // Packed Move with Sign Extend
case STARS_NN_pmovsxdq: // Packed Move with Sign Extend
case STARS_NN_pmovzxbw: // Packed Move with Zero Extend
case STARS_NN_pmovzxbd: // Packed Move with Zero Extend
case STARS_NN_pmovzxbq: // Packed Move with Zero Extend
case STARS_NN_pmovzxwd: // Packed Move with Zero Extend
case STARS_NN_pmovzxwq: // Packed Move with Zero Extend
case STARS_NN_pmovzxdq: // Packed Move with Zero Extend
case STARS_NN_pmuldq: // Multiply Packed Signed Dword Integers
case STARS_NN_pmulld: // Multiply Packed Signed Dword Integers and Store Low Result
case STARS_NN_ptest: // Logical Compare
case STARS_NN_roundpd: // Round Packed Double Precision Floating-Point Values
case STARS_NN_roundps: // Round Packed Single Precision Floating-Point Values
case STARS_NN_roundsd: // Round Scalar Double Precision Floating-Point Values
case STARS_NN_roundss: // Round Scalar Single Precision Floating-Point Values
SMP_fprintf(OutFile, "ERROR");
break;
// SSSE4.2 instructions
case STARS_NN_crc32: // Accumulate CRC32 Value
case STARS_NN_pcmpestri: // Packed Compare Explicit Length Strings: Return Index
case STARS_NN_pcmpestrm: // Packed Compare Explicit Length Strings: Return Mask
case STARS_NN_pcmpistri: // Packed Compare Implicit Length Strings: Return Index
case STARS_NN_pcmpistrm: // Packed Compare Implicit Length Strings: Return Mask
case STARS_NN_pcmpgtq: // Compare Packed Data for Greater Than
case STARS_NN_popcnt: // Return the Count of Number of Bits Set to 1
SMP_fprintf(OutFile, "ERROR");
break;
// AMD SSE4a instructions
case STARS_NN_extrq: // Extract Field From Register
case STARS_NN_insertq: // Insert Field
case STARS_NN_movntsd: // Move Non-Temporal Scalar Double-Precision Floating-Point
case STARS_NN_movntss: // Move Non-Temporal Scalar Single-Precision Floating-Point
case STARS_NN_lzcnt: // Leading Zero Count
SMP_fprintf(OutFile, "ERROR");
break;
// xsave/xrstor instructions
case STARS_NN_xgetbv: // Get Value of Extended Control Register
case STARS_NN_xrstor: // Restore Processor Extended States
case STARS_NN_xsave: // Save Processor Extended States
case STARS_NN_xsetbv: // Set Value of Extended Control Register
SMP_fprintf(OutFile, "ERROR");
break;
// Intel Safer Mode Extensions (SMX)
case STARS_NN_getsec: // Safer Mode Extensions (SMX) Instruction
SMP_fprintf(OutFile, "ERROR");
break;
// AMD-V Virtualization ISA Extension
case STARS_NN_clgi: // Clear Global Interrupt Flag
case STARS_NN_invlpga: // Invalidate TLB Entry in a Specified ASID
case STARS_NN_skinit: // Secure Init and Jump with Attestation
case STARS_NN_stgi: // Set Global Interrupt Flag
case STARS_NN_vmexit: // Stop Executing Guest: Begin Executing Host
case STARS_NN_vmload: // Load State from VMCB
case STARS_NN_vmmcall: // Call VMM
case STARS_NN_vmrun: // Run Virtual Machine
case STARS_NN_vmsave: // Save State to VMCB
SMP_fprintf(OutFile, "ERROR");
break;
// VMX+ instructions
case STARS_NN_invept: // Invalidate Translations Derived from EPT
case STARS_NN_invvpid: // Invalidate Translations Based on VPID
SMP_fprintf(OutFile, "ERROR");
break;
// Intel Atom instructions
case STARS_NN_movbe: // Move Data After Swapping Bytes
SMP_fprintf(OutFile, "ERROR");
break;
// Intel AES instructions
case STARS_NN_aesenc: // Perform One Round of an AES Encryption Flow
case STARS_NN_aesenclast: // Perform the Last Round of an AES Encryption Flow
case STARS_NN_aesdec: // Perform One Round of an AES Decryption Flow
case STARS_NN_aesdeclast: // Perform the Last Round of an AES Decryption Flow
case STARS_NN_aesimc: // Perform the AES InvMixColumn Transformation
case STARS_NN_aeskeygenassist: // AES Round Key Generation Assist
SMP_fprintf(OutFile, "ERROR");
break;
// Carryless multiplication
case STARS_NN_pclmulqdq: // Carry-Less Multiplication Quadword
SMP_fprintf(OutFile, "ERROR");
break;
// Returns modifies by operand size prefixes
case STARS_NN_retnw: // Return Near from Procedure (use16)
case STARS_NN_retnd: // Return Near from Procedure (use32)
case STARS_NN_retnq: // Return Near from Procedure (use64)
case STARS_NN_retfw: // Return Far from Procedure (use16)
case STARS_NN_retfd: // Return Far from Procedure (use32)
case STARS_NN_retfq: // Return Far from Procedure (use64)
SMP_fprintf(OutFile, "return");
break;
// RDRAND support
case STARS_NN_rdrand: // Read Random Number
SMP_fprintf(OutFile, "ERROR");
break;
// new GPR instructions
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
case STARS_NN_adcx: // Unsigned Integer Addition of Two Operands with Carry Flag
case STARS_NN_adox: // Unsigned Integer Addition of Two Operands with Overflow Flag
case STARS_NN_andn: // Logical AND NOT
case STARS_NN_bextr: // Bit Field Extract
case STARS_NN_blsi: // Extract Lowest Set Isolated Bit
case STARS_NN_blsmsk: // Get Mask Up to Lowest Set Bit
case STARS_NN_blsr: // Reset Lowest Set Bit
case STARS_NN_bzhi: // Zero High Bits Starting with Specified Bit Position
case STARS_NN_clac: // Clear AC Flag in EFLAGS Register
case STARS_NN_mulx: // Unsigned Multiply Without Affecting Flags
case STARS_NN_pdep: // Parallel Bits Deposit
case STARS_NN_pext: // Parallel Bits Extract
case STARS_NN_rorx: // Rotate Right Logical Without Affecting Flags
case STARS_NN_sarx: // Shift Arithmetically Right Without Affecting Flags
case STARS_NN_shlx: // Shift Logically Left Without Affecting Flags
case STARS_NN_shrx: // Shift Logically Right Without Affecting Flags
case STARS_NN_stac: // Set AC Flag in EFLAGS Register
case STARS_NN_tzcnt: // Count the Number of Trailing Zero Bits
case STARS_NN_xsaveopt: // Save Processor Extended States Optimized
case STARS_NN_invpcid: // Invalidate Processor Context ID
case STARS_NN_rdseed: // Read Random Seed
case STARS_NN_rdfsbase: // Read FS Segment Base
case STARS_NN_rdgsbase: // Read GS Segment Base
case STARS_NN_wrfsbase: // Write FS Segment Base
case STARS_NN_wrgsbase: // Write GS Segment Base
SMP_fprintf(OutFile, "ERROR");
break;
// new AVX instructions
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
case STARS_NN_vaddpd: // Add Packed Double-Precision Floating-Point Values
case STARS_NN_vaddps: // Packed Single-FP Add
case STARS_NN_vaddsd: // Add Scalar Double-Precision Floating-Point Values
case STARS_NN_vaddss: // Scalar Single-FP Add
case STARS_NN_vaddsubpd: // Add /Sub packed DP FP numbers
case STARS_NN_vaddsubps: // Add /Sub packed SP FP numbers
case STARS_NN_vaesdec: // Perform One Round of an AES Decryption Flow
case STARS_NN_vaesdeclast: // Perform the Last Round of an AES Decryption Flow
case STARS_NN_vaesenc: // Perform One Round of an AES Encryption Flow
case STARS_NN_vaesenclast: // Perform the Last Round of an AES Encryption Flow
case STARS_NN_vaesimc: // Perform the AES InvMixColumn Transformation
case STARS_NN_vaeskeygenassist: // AES Round Key Generation Assist
case STARS_NN_vandnpd: // Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values
case STARS_NN_vandnps: // Bitwise Logical And Not for Single-FP
case STARS_NN_vandpd: // Bitwise Logical AND of Packed Double-Precision Floating-Point Values
case STARS_NN_vandps: // Bitwise Logical And for Single-FP
case STARS_NN_vblendpd: // Blend Packed Double Precision Floating-Point Values
case STARS_NN_vblendps: // Blend Packed Single Precision Floating-Point Values
case STARS_NN_vblendvpd: // Variable Blend Packed Double Precision Floating-Point Values
case STARS_NN_vblendvps: // Variable Blend Packed Single Precision Floating-Point Values
case STARS_NN_vbroadcastf128: // Broadcast 128 Bits of Floating-Point Data
case STARS_NN_vbroadcasti128: // Broadcast 128 Bits of Integer Data
case STARS_NN_vbroadcastsd: // Broadcast Double-Precision Floating-Point Element
case STARS_NN_vbroadcastss: // Broadcast Single-Precision Floating-Point Element
case STARS_NN_vcmppd: // Compare Packed Double-Precision Floating-Point Values
case STARS_NN_vcmpps: // Packed Single-FP Compare
case STARS_NN_vcmpsd: // Compare Scalar Double-Precision Floating-Point Values
case STARS_NN_vcmpss: // Scalar Single-FP Compare
case STARS_NN_vcomisd: // Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
case STARS_NN_vcomiss: // Scalar Ordered Single-FP Compare and Set EFLAGS
case STARS_NN_vcvtdq2pd: // Convert Packed Doubleword Integers to Packed Single-Precision Floating-Point Values
case STARS_NN_vcvtdq2ps: // Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values
case STARS_NN_vcvtpd2dq: // Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_vcvtpd2ps: // Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values
case STARS_NN_vcvtph2ps: // Convert 16-bit FP Values to Single-Precision FP Values
case STARS_NN_vcvtps2dq: // Convert Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_vcvtps2pd: // Convert Packed Single-Precision Floating-Point Values to Packed Double-Precision Floating-Point Values
case STARS_NN_vcvtps2ph: // Convert Single-Precision FP value to 16-bit FP value
case STARS_NN_vcvtsd2si: // Convert Scalar Double-Precision Floating-Point Value to Doubleword Integer
case STARS_NN_vcvtsd2ss: // Convert Scalar Double-Precision Floating-Point Value to Scalar Single-Precision Floating-Point Value
case STARS_NN_vcvtsi2sd: // Convert Doubleword Integer to Scalar Double-Precision Floating-Point Value
case STARS_NN_vcvtsi2ss: // Scalar signed INT32 to Single-FP conversion
case STARS_NN_vcvtss2sd: // Convert Scalar Single-Precision Floating-Point Value to Scalar Double-Precision Floating-Point Value
case STARS_NN_vcvtss2si: // Scalar Single-FP to signed INT32 conversion
case STARS_NN_vcvttpd2dq: // Convert With Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_vcvttps2dq: // Convert With Truncation Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
case STARS_NN_vcvttsd2si: // Convert with Truncation Scalar Double-Precision Floating-Point Value to Doubleword Integer
case STARS_NN_vcvttss2si: // Scalar Single-FP to signed INT32 conversion (truncate)
case STARS_NN_vdivpd: // Divide Packed Double-Precision Floating-Point Values
case STARS_NN_vdivps: // Packed Single-FP Divide
case STARS_NN_vdivsd: // Divide Scalar Double-Precision Floating-Point Values
case STARS_NN_vdivss: // Scalar Single-FP Divide
case STARS_NN_vdppd: // Dot Product of Packed Double Precision Floating-Point Values
case STARS_NN_vdpps: // Dot Product of Packed Single Precision Floating-Point Values
case STARS_NN_vextractf128: // Extract Packed Floating-Point Values
case STARS_NN_vextracti128: // Extract Packed Integer Values
case STARS_NN_vextractps: // Extract Packed Floating-Point Values
case STARS_NN_vfmadd132pd: // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmadd132ps: // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmadd132sd: // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfmadd132ss: // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfmadd213pd: // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmadd213ps: // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmadd213sd: // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfmadd213ss: // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfmadd231pd: // Fused Multiply-Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmadd231ps: // Fused Multiply-Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmadd231sd: // Fused Multiply-Add of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfmadd231ss: // Fused Multiply-Add of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfmaddsub132pd: // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmaddsub132ps: // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmaddsub213pd: // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmaddsub213ps: // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmaddsub231pd: // Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmaddsub231ps: // Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmsub132pd: // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmsub132ps: // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmsub132sd: // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfmsub132ss: // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfmsub213pd: // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmsub213ps: // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmsub213sd: // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfmsub213ss: // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfmsub231pd: // Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmsub231ps: // Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmsub231sd: // Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfmsub231ss: // Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfmsubadd132pd: // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmsubadd132ps: // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmsubadd213pd: // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmsubadd213ps: // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfmsubadd231pd: // Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfmsubadd231ps: // Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmadd132pd: // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfnmadd132ps: // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmadd132sd: // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfnmadd132ss: // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfnmadd213pd: // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfnmadd213ps: // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmadd213sd: // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfnmadd213ss: // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfnmadd231pd: // Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values
case STARS_NN_vfnmadd231ps: // Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmadd231sd: // Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfnmadd231ss: // Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfnmsub132pd: // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfnmsub132ps: // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmsub132sd: // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfnmsub132ss: // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfnmsub213pd: // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfnmsub213ps: // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmsub213sd: // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfnmsub213ss: // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
case STARS_NN_vfnmsub231pd: // Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values
case STARS_NN_vfnmsub231ps: // Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values
case STARS_NN_vfnmsub231sd: // Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values
case STARS_NN_vfnmsub231ss: // Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values
case STARS_NN_vgatherdps: // Gather Packed SP FP Values Using Signed Dword Indices
case STARS_NN_vgatherdpd: // Gather Packed DP FP Values Using Signed Dword Indices
case STARS_NN_vgatherqps: // Gather Packed SP FP Values Using Signed Qword Indices
case STARS_NN_vgatherqpd: // Gather Packed DP FP Values Using Signed Qword Indices
case STARS_NN_vhaddpd: // Add horizontally packed DP FP numbers
case STARS_NN_vhaddps: // Add horizontally packed SP FP numbers
case STARS_NN_vhsubpd: // Sub horizontally packed DP FP numbers
case STARS_NN_vhsubps: // Sub horizontally packed SP FP numbers
case STARS_NN_vinsertf128: // Insert Packed Floating-Point Values
case STARS_NN_vinserti128: // Insert Packed Integer Values
case STARS_NN_vinsertps: // Insert Packed Single Precision Floating-Point Value
case STARS_NN_vlddqu: // Load Unaligned Packed Integer Values
case STARS_NN_vldmxcsr: // Load Streaming SIMD Extensions Technology Control/Status Register
case STARS_NN_vmaskmovdqu: // Store Selected Bytes of Double Quadword with NT Hint
case STARS_NN_vmaskmovpd: // Conditionally Load Packed Double-Precision Floating-Point Values
case STARS_NN_vmaskmovps: // Conditionally Load Packed Single-Precision Floating-Point Values
case STARS_NN_vmaxpd: // Return Maximum Packed Double-Precision Floating-Point Values
case STARS_NN_vmaxps: // Packed Single-FP Maximum
case STARS_NN_vmaxsd: // Return Maximum Scalar Double-Precision Floating-Point Value
case STARS_NN_vmaxss: // Scalar Single-FP Maximum
case STARS_NN_vminpd: // Return Minimum Packed Double-Precision Floating-Point Values
case STARS_NN_vminps: // Packed Single-FP Minimum
case STARS_NN_vminsd: // Return Minimum Scalar Double-Precision Floating-Point Value
case STARS_NN_vminss: // Scalar Single-FP Minimum
case STARS_NN_vmovapd: // Move Aligned Packed Double-Precision Floating-Point Values
case STARS_NN_vmovaps: // Move Aligned Four Packed Single-FP
case STARS_NN_vmovd: // Move 32 bits
case STARS_NN_vmovddup: // Move One Double-FP and Duplicate
case STARS_NN_vmovdqa: // Move Aligned Double Quadword
case STARS_NN_vmovdqu: // Move Unaligned Double Quadword
case STARS_NN_vmovhlps: // Move High to Low Packed Single-FP
case STARS_NN_vmovhpd: // Move High Packed Double-Precision Floating-Point Values
case STARS_NN_vmovhps: // Move High Packed Single-FP
case STARS_NN_vmovlhps: // Move Low to High Packed Single-FP
case STARS_NN_vmovlpd: // Move Low Packed Double-Precision Floating-Point Values
case STARS_NN_vmovlps: // Move Low Packed Single-FP
case STARS_NN_vmovmskpd: // Extract Packed Double-Precision Floating-Point Sign Mask
case STARS_NN_vmovmskps: // Move Mask to Register
case STARS_NN_vmovntdq: // Store Double Quadword Using Non-Temporal Hint
case STARS_NN_vmovntdqa: // Load Double Quadword Non-Temporal Aligned Hint
case STARS_NN_vmovntpd: // Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint
case STARS_NN_vmovntps: // Move Aligned Four Packed Single-FP Non Temporal
#if (IDA_SDK_VERSION < 700) // Incredibly, these opcodes were removed in IDA Pro 7.0
case STARS_NN_vmovntsd: // Move Non-Temporal Scalar Double-Precision Floating-Point
case STARS_NN_vmovntss: // Move Non-Temporal Scalar Single-Precision Floating-Point
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
case STARS_NN_vmovq: // Move 64 bits
case STARS_NN_vmovsd: // Move Scalar Double-Precision Floating-Point Values
case STARS_NN_vmovshdup: // Move Packed Single-FP High and Duplicate
case STARS_NN_vmovsldup: // Move Packed Single-FP Low and Duplicate
case STARS_NN_vmovss: // Move Scalar Single-FP
case STARS_NN_vmovupd: // Move Unaligned Packed Double-Precision Floating-Point Values
case STARS_NN_vmovups: // Move Unaligned Four Packed Single-FP
case STARS_NN_vmpsadbw: // Compute Multiple Packed Sums of Absolute Difference
case STARS_NN_vmulpd: // Multiply Packed Double-Precision Floating-Point Values
case STARS_NN_vmulps: // Packed Single-FP Multiply
case STARS_NN_vmulsd: // Multiply Scalar Double-Precision Floating-Point Values
case STARS_NN_vmulss: // Scalar Single-FP Multiply
case STARS_NN_vorpd: // Bitwise Logical OR of Double-Precision Floating-Point Values
case STARS_NN_vorps: // Bitwise Logical OR for Single-FP Data
case STARS_NN_vpabsb: // Packed Absolute Value Byte
case STARS_NN_vpabsd: // Packed Absolute Value Doubleword
case STARS_NN_vpabsw: // Packed Absolute Value Word
case STARS_NN_vpackssdw: // Pack with Signed Saturation (Dword->Word)
case STARS_NN_vpacksswb: // Pack with Signed Saturation (Word->Byte)
case STARS_NN_vpackusdw: // Pack with Unsigned Saturation
case STARS_NN_vpackuswb: // Pack with Unsigned Saturation (Word->Byte)
case STARS_NN_vpaddb: // Packed Add Byte
case STARS_NN_vpaddd: // Packed Add Dword
case STARS_NN_vpaddq: // Add Packed Quadword Integers
case STARS_NN_vpaddsb: // Packed Add with Saturation (Byte)
case STARS_NN_vpaddsw: // Packed Add with Saturation (Word)
case STARS_NN_vpaddusb: // Packed Add Unsigned with Saturation (Byte)
case STARS_NN_vpaddusw: // Packed Add Unsigned with Saturation (Word)
case STARS_NN_vpaddw: // Packed Add Word
case STARS_NN_vpalignr: // Packed Align Right
case STARS_NN_vpand: // Bitwise Logical And
case STARS_NN_vpandn: // Bitwise Logical And Not
case STARS_NN_vpavgb: // Packed Average (Byte)
case STARS_NN_vpavgw: // Packed Average (Word)
case STARS_NN_vpblendd: // Blend Packed Dwords
case STARS_NN_vpblendvb: // Variable Blend Packed Bytes
case STARS_NN_vpblendw: // Blend Packed Words
case STARS_NN_vpbroadcastb: // Broadcast a Byte Integer
case STARS_NN_vpbroadcastd: // Broadcast a Dword Integer
case STARS_NN_vpbroadcastq: // Broadcast a Qword Integer
case STARS_NN_vpbroadcastw: // Broadcast a Word Integer
case STARS_NN_vpclmulqdq: // Carry-Less Multiplication Quadword
case STARS_NN_vpcmpeqb: // Packed Compare for Equal (Byte)
case STARS_NN_vpcmpeqd: // Packed Compare for Equal (Dword)
case STARS_NN_vpcmpeqq: // Compare Packed Qword Data for Equal
case STARS_NN_vpcmpeqw: // Packed Compare for Equal (Word)
case STARS_NN_vpcmpestri: // Packed Compare Explicit Length Strings: Return Index
case STARS_NN_vpcmpestrm: // Packed Compare Explicit Length Strings: Return Mask
case STARS_NN_vpcmpgtb: // Packed Compare for Greater Than (Byte)
case STARS_NN_vpcmpgtd: // Packed Compare for Greater Than (Dword)
case STARS_NN_vpcmpgtq: // Compare Packed Data for Greater Than
case STARS_NN_vpcmpgtw: // Packed Compare for Greater Than (Word)
case STARS_NN_vpcmpistri: // Packed Compare Implicit Length Strings: Return Index
case STARS_NN_vpcmpistrm: // Packed Compare Implicit Length Strings: Return Mask
case STARS_NN_vperm2f128: // Permute Floating-Point Values
case STARS_NN_vperm2i128: // Permute Integer Values
case STARS_NN_vpermd: // Full Doublewords Element Permutation
case STARS_NN_vpermilpd: // Permute Double-Precision Floating-Point Values
case STARS_NN_vpermilps: // Permute Single-Precision Floating-Point Values
case STARS_NN_vpermpd: // Permute Double-Precision Floating-Point Elements
case STARS_NN_vpermps: // Permute Single-Precision Floating-Point Elements
case STARS_NN_vpermq: // Qwords Element Permutation
case STARS_NN_vpextrb: // Extract Byte
case STARS_NN_vpextrd: // Extract Dword
case STARS_NN_vpextrq: // Extract Qword
case STARS_NN_vpextrw: // Extract Word
case STARS_NN_vpgatherdd: // Gather Packed Dword Values Using Signed Dword Indices
case STARS_NN_vpgatherdq: // Gather Packed Qword Values Using Signed Dword Indices
case STARS_NN_vpgatherqd: // Gather Packed Dword Values Using Signed Qword Indices
case STARS_NN_vpgatherqq: // Gather Packed Qword Values Using Signed Qword Indices
case STARS_NN_vphaddd: // Packed Horizontal Add Doubleword
case STARS_NN_vphaddsw: // Packed Horizontal Add and Saturate
case STARS_NN_vphaddw: // Packed Horizontal Add Word
case STARS_NN_vphminposuw: // Packed Horizontal Word Minimum
case STARS_NN_vphsubd: // Packed Horizontal Subtract Doubleword
case STARS_NN_vphsubsw: // Packed Horizontal Subtract and Saturate
case STARS_NN_vphsubw: // Packed Horizontal Subtract Word
case STARS_NN_vpinsrb: // Insert Byte
case STARS_NN_vpinsrd: // Insert Dword
case STARS_NN_vpinsrq: // Insert Qword
case STARS_NN_vpinsrw: // Insert Word
case STARS_NN_vpmaddubsw: // Multiply and Add Packed Signed and Unsigned Bytes
case STARS_NN_vpmaddwd: // Packed Multiply and Add
case STARS_NN_vpmaskmovd: // Conditionally Store Dword Values Using Mask
case STARS_NN_vpmaskmovq: // Conditionally Store Qword Values Using Mask
case STARS_NN_vpmaxsb: // Maximum of Packed Signed Byte Integers
case STARS_NN_vpmaxsd: // Maximum of Packed Signed Dword Integers
case STARS_NN_vpmaxsw: // Packed Signed Integer Word Maximum
case STARS_NN_vpmaxub: // Packed Unsigned Integer Byte Maximum
case STARS_NN_vpmaxud: // Maximum of Packed Unsigned Dword Integers
case STARS_NN_vpmaxuw: // Maximum of Packed Word Integers
case STARS_NN_vpminsb: // Minimum of Packed Signed Byte Integers
case STARS_NN_vpminsd: // Minimum of Packed Signed Dword Integers
case STARS_NN_vpminsw: // Packed Signed Integer Word Minimum
case STARS_NN_vpminub: // Packed Unsigned Integer Byte Minimum
case STARS_NN_vpminud: // Minimum of Packed Unsigned Dword Integers
case STARS_NN_vpminuw: // Minimum of Packed Word Integers
case STARS_NN_vpmovmskb: // Move Byte Mask to Integer
case STARS_NN_vpmovsxbd: // Packed Move with Sign Extend
case STARS_NN_vpmovsxbq: // Packed Move with Sign Extend
case STARS_NN_vpmovsxbw: // Packed Move with Sign Extend
case STARS_NN_vpmovsxdq: // Packed Move with Sign Extend
case STARS_NN_vpmovsxwd: // Packed Move with Sign Extend
case STARS_NN_vpmovsxwq: // Packed Move with Sign Extend
case STARS_NN_vpmovzxbd: // Packed Move with Zero Extend
case STARS_NN_vpmovzxbq: // Packed Move with Zero Extend
case STARS_NN_vpmovzxbw: // Packed Move with Zero Extend
case STARS_NN_vpmovzxdq: // Packed Move with Zero Extend
case STARS_NN_vpmovzxwd: // Packed Move with Zero Extend
case STARS_NN_vpmovzxwq: // Packed Move with Zero Extend
case STARS_NN_vpmuldq: // Multiply Packed Signed Dword Integers
case STARS_NN_vpmulhrsw: // Packed Multiply High with Round and Scale
case STARS_NN_vpmulhuw: // Packed Multiply High Unsigned
case STARS_NN_vpmulhw: // Packed Multiply High
case STARS_NN_vpmulld: // Multiply Packed Signed Dword Integers and Store Low Result
case STARS_NN_vpmullw: // Packed Multiply Low
case STARS_NN_vpmuludq: // Multiply Packed Unsigned Doubleword Integers
case STARS_NN_vpor: // Bitwise Logical Or
case STARS_NN_vpsadbw: // Packed Sum of Absolute Differences
case STARS_NN_vpshufb: // Packed Shuffle Bytes
case STARS_NN_vpshufd: // Shuffle Packed Doublewords
case STARS_NN_vpshufhw: // Shuffle Packed High Words
case STARS_NN_vpshuflw: // Shuffle Packed Low Words
case STARS_NN_vpsignb: // Packed SIGN Byte
case STARS_NN_vpsignd: // Packed SIGN Doubleword
case STARS_NN_vpsignw: // Packed SIGN Word
case STARS_NN_vpslld: // Packed Shift Left Logical (Dword)
case STARS_NN_vpslldq: // Shift Double Quadword Left Logical
case STARS_NN_vpsllq: // Packed Shift Left Logical (Qword)
case STARS_NN_vpsllvd: // Variable Bit Shift Left Logical (Dword)
case STARS_NN_vpsllvq: // Variable Bit Shift Left Logical (Qword)
case STARS_NN_vpsllw: // Packed Shift Left Logical (Word)
case STARS_NN_vpsrad: // Packed Shift Right Arithmetic (Dword)
case STARS_NN_vpsravd: // Variable Bit Shift Right Arithmetic
case STARS_NN_vpsraw: // Packed Shift Right Arithmetic (Word)
case STARS_NN_vpsrld: // Packed Shift Right Logical (Dword)
case STARS_NN_vpsrldq: // Shift Double Quadword Right Logical (Qword)
case STARS_NN_vpsrlq: // Packed Shift Right Logical (Qword)
case STARS_NN_vpsrlvd: // Variable Bit Shift Right Logical (Dword)
case STARS_NN_vpsrlvq: // Variable Bit Shift Right Logical (Qword)
case STARS_NN_vpsrlw: // Packed Shift Right Logical (Word)
case STARS_NN_vpsubb: // Packed Subtract Byte
case STARS_NN_vpsubd: // Packed Subtract Dword
case STARS_NN_vpsubq: // Subtract Packed Quadword Integers
case STARS_NN_vpsubsb: // Packed Subtract with Saturation (Byte)
case STARS_NN_vpsubsw: // Packed Subtract with Saturation (Word)
case STARS_NN_vpsubusb: // Packed Subtract Unsigned with Saturation (Byte)
case STARS_NN_vpsubusw: // Packed Subtract Unsigned with Saturation (Word)
case STARS_NN_vpsubw: // Packed Subtract Word
case STARS_NN_vptest: // Logical Compare
case STARS_NN_vpunpckhbw: // Unpack High Packed Data (Byte->Word)
case STARS_NN_vpunpckhdq: // Unpack High Packed Data (Dword->Qword)
case STARS_NN_vpunpckhqdq: // Unpack High Packed Data (Qword->Xmmword)
case STARS_NN_vpunpckhwd: // Unpack High Packed Data (Word->Dword)
case STARS_NN_vpunpcklbw: // Unpack Low Packed Data (Byte->Word)
case STARS_NN_vpunpckldq: // Unpack Low Packed Data (Dword->Qword)
case STARS_NN_vpunpcklqdq: // Unpack Low Packed Data (Qword->Xmmword)
case STARS_NN_vpunpcklwd: // Unpack Low Packed Data (Word->Dword)
case STARS_NN_vpxor: // Bitwise Logical Exclusive Or
case STARS_NN_vrcpps: // Packed Single-FP Reciprocal
case STARS_NN_vrcpss: // Scalar Single-FP Reciprocal
case STARS_NN_vroundpd: // Round Packed Double Precision Floating-Point Values
case STARS_NN_vroundps: // Round Packed Single Precision Floating-Point Values
case STARS_NN_vroundsd: // Round Scalar Double Precision Floating-Point Values
case STARS_NN_vroundss: // Round Scalar Single Precision Floating-Point Values
case STARS_NN_vrsqrtps: // Packed Single-FP Square Root Reciprocal
case STARS_NN_vrsqrtss: // Scalar Single-FP Square Root Reciprocal
case STARS_NN_vshufpd: // Shuffle Packed Double-Precision Floating-Point Values
case STARS_NN_vshufps: // Shuffle Single-FP
case STARS_NN_vsqrtpd: // Compute Square Roots of Packed Double-Precision Floating-Point Values
case STARS_NN_vsqrtps: // Packed Single-FP Square Root
case STARS_NN_vsqrtsd: // Compute Square Rootof Scalar Double-Precision Floating-Point Value
case STARS_NN_vsqrtss: // Scalar Single-FP Square Root
case STARS_NN_vstmxcsr: // Store Streaming SIMD Extensions Technology Control/Status Register
case STARS_NN_vsubpd: // Subtract Packed Double-Precision Floating-Point Values
case STARS_NN_vsubps: // Packed Single-FP Subtract
case STARS_NN_vsubsd: // Subtract Scalar Double-Precision Floating-Point Values
case STARS_NN_vsubss: // Scalar Single-FP Subtract
case STARS_NN_vtestpd: // Packed Double-Precision Floating-Point Bit Test
case STARS_NN_vtestps: // Packed Single-Precision Floating-Point Bit Test
case STARS_NN_vucomisd: // Unordered Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
case STARS_NN_vucomiss: // Scalar Unordered Single-FP Compare and Set EFLAGS
case STARS_NN_vunpckhpd: // Unpack and Interleave High Packed Double-Precision Floating-Point Values
case STARS_NN_vunpckhps: // Unpack High Packed Single-FP Data
case STARS_NN_vunpcklpd: // Unpack and Interleave Low Packed Double-Precision Floating-Point Values
case STARS_NN_vunpcklps: // Unpack Low Packed Single-FP Data
case STARS_NN_vxorpd: // Bitwise Logical OR of Double-Precision Floating-Point Values
case STARS_NN_vxorps: // Bitwise Logical XOR for Single-FP Data
case STARS_NN_vzeroall: // Zero All YMM Registers
case STARS_NN_vzeroupper: // Zero Upper Bits of YMM Registers
SMP_fprintf(OutFile, "ERROR");
break;
// Transactional Synchronization Extensions
case STARS_NN_xabort: // Transaction Abort
case STARS_NN_xbegin: // Transaction Begin
case STARS_NN_xend: // Transaction End
case STARS_NN_xtest: // Test If In Transactional Execution
SMP_fprintf(OutFile, "ERROR");
break;
// Virtual PC synthetic instructions
case STARS_NN_vmgetinfo: // Virtual PC - Get VM Information
case STARS_NN_vmsetinfo: // Virtual PC - Set VM Information
case STARS_NN_vmdxdsbl: // Virtual PC - Disable Direct Execution
case STARS_NN_vmdxenbl: // Virtual PC - Enable Direct Execution
case STARS_NN_vmcpuid: // Virtual PC - Virtualized CPU Information
case STARS_NN_vmhlt: // Virtual PC - Halt
case STARS_NN_vmsplaf: // Virtual PC - Spin Lock Acquisition Failed
case STARS_NN_vmpushfd: // Virtual PC - Push virtualized flags register
case STARS_NN_vmpopfd: // Virtual PC - Pop virtualized flags register
case STARS_NN_vmcli: // Virtual PC - Clear Interrupt Flag
case STARS_NN_vmsti: // Virtual PC - Set Interrupt Flag
case STARS_NN_vmiretd: // Virtual PC - Return From Interrupt
case STARS_NN_vmsgdt: // Virtual PC - Store Global Descriptor Table
case STARS_NN_vmsidt: // Virtual PC - Store Interrupt Descriptor Table
case STARS_NN_vmsldt: // Virtual PC - Store Local Descriptor Table
case STARS_NN_vmstr: // Virtual PC - Store Task Register
case STARS_NN_vmsdte: // Virtual PC - Store to Descriptor Table Entry
case STARS_NN_vpcext: // Virtual PC - ISA extension
SMP_fprintf(OutFile, "ERROR");
break;
case STARS_NN_last:
SMP_fprintf(OutFile, "ERROR");
break;
default:
SMP_fprintf(OutFile, "ERROR");
break;
}
return;
} // end of PrintOpcode()
// MACHINE DEPENDENT: Is operand type a known type that we want to analyze?
bool MDKnownOperandType(const STARSOpndTypePtr &TempOp) {
bool GoodOpType = (nullptr != TempOp) && TempOp->MDIsKnownOpType();
#if SMP_DEBUG_OPERAND_TYPES
if (!GoodOpType && (! TempOp->IsVoidOp())) {
SMP_msg("WARNING: Operand type %d \n", TempOp->GetOpType());
}
#endif
return GoodOpType;
// Meet function over any two types in the type lattice.
SMPOperandType SMPTypeMeet(SMPOperandType Type1, SMPOperandType Type2, bool &ErrorFlag) {
bool ProfDerived = IsProfDerived(Type1) || IsProfDerived(Type2);
if (IsEqType(UNINIT, Type1))
MeetType = Type2;
else if (IsEqType(UNINIT, Type2) || IsEqType(Type1, Type2)
|| IsUnknown(Type1))
MeetType = Type1;
else if (IsNumeric(Type1)) {
if (IsNumeric(Type2)) // one is NUMERIC, one is CODEPTR
clc5q
committed
MeetType = CODEPTR;
else if (IsDataPtr(Type2) || IsUnknown(Type2))
MeetType = UNKNOWN;
clc5q
committed
SMP_msg("ERROR #1 in SMPTypeMeet.\n");
ErrorFlag = true;
}
}
else if (IsDataPtr(Type1)) {
if (IsDataPtr(Type2)) // two different POINTER subtypes
MeetType = POINTER;
else if (IsNumeric(Type2) || IsUnknown(Type2))
MeetType = UNKNOWN;
clc5q
committed
SMP_msg("ERROR #2 in SMPTypeMeet.\n");
ErrorFlag = true;
}
if (ProfDerived && IsNotEqType(UNINIT, MeetType))
MeetType = MakeProfDerived(MeetType);
// Meet function for SCCP constant propagation; updates NewConstStruct