SMPDataFlowAnalysis.cpp

SMPTypeCategory[NN_vpinsrq] = 14;           // Insert Qword
SMPTypeCategory[NN_vpinsrw] = 14;           // Insert Word
SMPTypeCategory[NN_vpmaddubsw] = 14;        // Multiply and Add Packed Signed and Unsigned Bytes
SMPTypeCategory[NN_vpmaddwd] = 14;          // Packed Multiply and Add
SMPTypeCategory[NN_vpmaskmovd] = 15;        // Conditionally Store Dword Values Using Mask
SMPTypeCategory[NN_vpmaskmovq] = 15;        // Conditionally Store Qword Values Using Mask
SMPTypeCategory[NN_vpmaxsb] = 14;           // Maximum of Packed Signed Byte Integers
SMPTypeCategory[NN_vpmaxsd] = 14;           // Maximum of Packed Signed Dword Integers
SMPTypeCategory[NN_vpmaxsw] = 14;           // Packed Signed Integer Word Maximum
SMPTypeCategory[NN_vpmaxub] = 14;           // Packed Unsigned Integer Byte Maximum
SMPTypeCategory[NN_vpmaxud] = 14;           // Maximum of Packed Unsigned Dword Integers
SMPTypeCategory[NN_vpmaxuw] = 14;           // Maximum of Packed Word Integers
SMPTypeCategory[NN_vpminsb] = 14;           // Minimum of Packed Signed Byte Integers
SMPTypeCategory[NN_vpminsd] = 14;           // Minimum of Packed Signed Dword Integers
SMPTypeCategory[NN_vpminsw] = 14;           // Packed Signed Integer Word Minimum
SMPTypeCategory[NN_vpminub] = 14;           // Packed Unsigned Integer Byte Minimum
SMPTypeCategory[NN_vpminud] = 14;           // Minimum of Packed Unsigned Dword Integers
SMPTypeCategory[NN_vpminuw] = 14;           // Minimum of Packed Word Integers
SMPTypeCategory[NN_vpmovmskb] = 15;         // Move Byte Mask to Integer
SMPTypeCategory[NN_vpmovsxbd] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxbq] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxbw] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxdq] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxwd] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovsxwq] = 15;         // Packed Move with Sign Extend
SMPTypeCategory[NN_vpmovzxbd] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxbq] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxbw] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxdq] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxwd] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmovzxwq] = 15;         // Packed Move with Zero Extend
SMPTypeCategory[NN_vpmuldq] = 14;           // Multiply Packed Signed Dword Integers
SMPTypeCategory[NN_vpmulhrsw] = 14;         // Packed Multiply High with Round and Scale
SMPTypeCategory[NN_vpmulhuw] = 14;          // Packed Multiply High Unsigned
SMPTypeCategory[NN_vpmulhw] = 14;           // Packed Multiply High
SMPTypeCategory[NN_vpmulld] = 14;           // Multiply Packed Signed Dword Integers and Store Low Result
SMPTypeCategory[NN_vpmullw] = 14;           // Packed Multiply Low
SMPTypeCategory[NN_vpmuludq] = 14;          // Multiply Packed Unsigned Doubleword Integers
SMPTypeCategory[NN_vpor] = 14;              // Bitwise Logical Or
SMPTypeCategory[NN_vpsadbw] = 14;           // Packed Sum of Absolute Differences
SMPTypeCategory[NN_vpshufb] = 14;           // Packed Shuffle Bytes
SMPTypeCategory[NN_vpshufd] = 14;           // Shuffle Packed Doublewords
SMPTypeCategory[NN_vpshufhw] = 14;          // Shuffle Packed High Words
SMPTypeCategory[NN_vpshuflw] = 14;          // Shuffle Packed Low Words
SMPTypeCategory[NN_vpsignb] = 14;           // Packed SIGN Byte
SMPTypeCategory[NN_vpsignd] = 14;           // Packed SIGN Doubleword
SMPTypeCategory[NN_vpsignw] = 14;           // Packed SIGN Word
SMPTypeCategory[NN_vpslld] = 14;            // Packed Shift Left Logical (Dword)
SMPTypeCategory[NN_vpslldq] = 14;           // Shift Double Quadword Left Logical
SMPTypeCategory[NN_vpsllq] = 14;            // Packed Shift Left Logical (Qword)
SMPTypeCategory[NN_vpsllvd] = 14;           // Variable Bit Shift Left Logical (Dword)
SMPTypeCategory[NN_vpsllvq] = 14;           // Variable Bit Shift Left Logical (Qword)
SMPTypeCategory[NN_vpsllw] = 14;            // Packed Shift Left Logical (Word)
SMPTypeCategory[NN_vpsrad] = 14;            // Packed Shift Right Arithmetic (Dword)
SMPTypeCategory[NN_vpsravd] = 14;           // Variable Bit Shift Right Arithmetic
SMPTypeCategory[NN_vpsraw] = 14;            // Packed Shift Right Arithmetic (Word)
SMPTypeCategory[NN_vpsrld] = 14;            // Packed Shift Right Logical (Dword)
SMPTypeCategory[NN_vpsrldq] = 14;           // Shift Double Quadword Right Logical (Qword)
SMPTypeCategory[NN_vpsrlq] = 14;            // Packed Shift Right Logical (Qword)
SMPTypeCategory[NN_vpsrlvd] = 14;           // Variable Bit Shift Right Logical (Dword)
SMPTypeCategory[NN_vpsrlvq] = 14;           // Variable Bit Shift Right Logical (Qword)
SMPTypeCategory[NN_vpsrlw] = 14;            // Packed Shift Right Logical (Word)
SMPTypeCategory[NN_vpsubb] = 14;            // Packed Subtract Byte
SMPTypeCategory[NN_vpsubd] = 14;            // Packed Subtract Dword
SMPTypeCategory[NN_vpsubq] = 14;            // Subtract Packed Quadword Integers
SMPTypeCategory[NN_vpsubsb] = 14;           // Packed Subtract with Saturation (Byte)
SMPTypeCategory[NN_vpsubsw] = 14;           // Packed Subtract with Saturation (Word)
SMPTypeCategory[NN_vpsubusb] = 14;          // Packed Subtract Unsigned with Saturation (Byte)
SMPTypeCategory[NN_vpsubusw] = 14;          // Packed Subtract Unsigned with Saturation (Word)
SMPTypeCategory[NN_vpsubw] = 14;            // Packed Subtract Word
SMPTypeCategory[NN_vptest] = 14;            // Logical Compare
SMPTypeCategory[NN_vpunpckhbw] = 14;        // Unpack High Packed Data (Byte->Word)
SMPTypeCategory[NN_vpunpckhdq] = 14;        // Unpack High Packed Data (Dword->Qword)
SMPTypeCategory[NN_vpunpckhqdq] = 14;       // Unpack High Packed Data (Qword->Xmmword)
SMPTypeCategory[NN_vpunpckhwd] = 14;        // Unpack High Packed Data (Word->Dword)
SMPTypeCategory[NN_vpunpcklbw] = 14;        // Unpack Low Packed Data (Byte->Word)
SMPTypeCategory[NN_vpunpckldq] = 14;        // Unpack Low Packed Data (Dword->Qword)
SMPTypeCategory[NN_vpunpcklqdq] = 14;       // Unpack Low Packed Data (Qword->Xmmword)
SMPTypeCategory[NN_vpunpcklwd] = 14;        // Unpack Low Packed Data (Word->Dword)
SMPTypeCategory[NN_vpxor] = 14;             // Bitwise Logical Exclusive Or
SMPTypeCategory[NN_vrcpps] = 14;            // Packed Single-FP Reciprocal
SMPTypeCategory[NN_vrcpss] = 14;            // Scalar Single-FP Reciprocal
SMPTypeCategory[NN_vroundpd] = 14;          // Round Packed Double Precision Floating-Point Values
SMPTypeCategory[NN_vroundps] = 14;          // Round Packed Single Precision Floating-Point Values
SMPTypeCategory[NN_vroundsd] = 14;          // Round Scalar Double Precision Floating-Point Values
SMPTypeCategory[NN_vroundss] = 14;          // Round Scalar Single Precision Floating-Point Values
SMPTypeCategory[NN_vrsqrtps] = 14;          // Packed Single-FP Square Root Reciprocal
SMPTypeCategory[NN_vrsqrtss] = 14;          // Scalar Single-FP Square Root Reciprocal
SMPTypeCategory[NN_vshufpd] = 14;           // Shuffle Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vshufps] = 14;           // Shuffle Single-FP
SMPTypeCategory[NN_vsqrtpd] = 14;           // Compute Square Roots of Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vsqrtps] = 14;           // Packed Single-FP Square Root
SMPTypeCategory[NN_vsqrtsd] = 14;           // Compute Square Rootof Scalar Double-Precision Floating-Point Value
SMPTypeCategory[NN_vsqrtss] = 14;           // Scalar Single-FP Square Root
SMPTypeCategory[NN_vstmxcsr] = 14;          // Store Streaming SIMD Extensions Technology Control/Status Register
SMPTypeCategory[NN_vsubpd] = 14;            // Subtract Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vsubps] = 14;            // Packed Single-FP Subtract
SMPTypeCategory[NN_vsubsd] = 14;            // Subtract Scalar Double-Precision Floating-Point Values
SMPTypeCategory[NN_vsubss] = 14;            // Scalar Single-FP Subtract
SMPTypeCategory[NN_vtestpd] = 14;           // Packed Double-Precision Floating-Point Bit Test
SMPTypeCategory[NN_vtestps] = 14;           // Packed Single-Precision Floating-Point Bit Test
SMPTypeCategory[NN_vucomisd] = 14;          // Unordered Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
SMPTypeCategory[NN_vucomiss] = 14;          // Scalar Unordered Single-FP Compare and Set EFLAGS
SMPTypeCategory[NN_vunpckhpd] = 14;         // Unpack and Interleave High Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vunpckhps] = 14;         // Unpack High Packed Single-FP Data
SMPTypeCategory[NN_vunpcklpd] = 14;         // Unpack and Interleave Low Packed Double-Precision Floating-Point Values
SMPTypeCategory[NN_vunpcklps] = 14;         // Unpack Low Packed Single-FP Data
SMPTypeCategory[NN_vxorpd] = 14;            // Bitwise Logical OR of Double-Precision Floating-Point Values
SMPTypeCategory[NN_vxorps] = 14;            // Bitwise Logical XOR for Single-FP Data
SMPTypeCategory[NN_vzeroall] = 14;          // Zero All YMM Registers
SMPTypeCategory[NN_vzeroupper] = 14;        // Zero Upper Bits of YMM Registers

// Transactional Synchronization Extensions

SMPTypeCategory[NN_xabort] = 1;               // Transaction Abort
SMPTypeCategory[NN_xbegin] = 1;               // Transaction Begin
SMPTypeCategory[NN_xend] = 1;                 // Transaction End
SMPTypeCategory[NN_xtest] = 1;                // Test If In Transactional Execution

// Virtual PC synthetic instructions

SMPTypeCategory[NN_vmgetinfo] = 1;            // Virtual PC - Get VM Information
SMPTypeCategory[NN_vmsetinfo] = 1;            // Virtual PC - Set VM Information
SMPTypeCategory[NN_vmdxdsbl] = 1;             // Virtual PC - Disable Direct Execution
SMPTypeCategory[NN_vmdxenbl] = 1;             // Virtual PC - Enable Direct Execution
SMPTypeCategory[NN_vmcpuid] = 1;              // Virtual PC - Virtualized CPU Information
SMPTypeCategory[NN_vmhlt] = 1;                // Virtual PC - Halt
SMPTypeCategory[NN_vmsplaf] = 1;              // Virtual PC - Spin Lock Acquisition Failed
SMPTypeCategory[NN_vmpushfd] = 1;             // Virtual PC - Push virtualized flags register
SMPTypeCategory[NN_vmpopfd] = 1;              // Virtual PC - Pop virtualized flags register
SMPTypeCategory[NN_vmcli] = 1;                // Virtual PC - Clear Interrupt Flag
SMPTypeCategory[NN_vmsti] = 1;                // Virtual PC - Set Interrupt Flag
SMPTypeCategory[NN_vmiretd] = 1;              // Virtual PC - Return From Interrupt
SMPTypeCategory[NN_vmsgdt] = 1;               // Virtual PC - Store Global Descriptor Table
SMPTypeCategory[NN_vmsidt] = 1;               // Virtual PC - Store Interrupt Descriptor Table
SMPTypeCategory[NN_vmsldt] = 1;               // Virtual PC - Store Local Descriptor Table
SMPTypeCategory[NN_vmstr] = 1;                // Virtual PC - Store Task Register
SMPTypeCategory[NN_vmsdte] = 1;               // Virtual PC - Store to Descriptor Table Entry
SMPTypeCategory[NN_vpcext] = 1;               // Virtual PC - ISA extension

#endif  // 599 < IDA_SDK_VERSION

SMPTypeCategory[NN_last] = 1;

  return;

} // end InitTypeCategory()