IDAProdef.h

IDA pro 反编译exe时生成的C文件中#include的defs.h 文件在IDA目录下plugins文件夹内

/*

   This file contains definitions used by the Hex-Rays decompiler output.
   It has type definitions and convenience macros to make the
   output more readable.

   Copyright (c) 2007-2015 Hex-Rays

*/

#ifndef HEXRAYS_DEFS_H
#define HEXRAYS_DEFS_H

#if defined(__GNUC__)
  typedef          long long ll;
  typedef unsigned long long ull;
  #define __int64 long long
  #define __int32 int
  #define __int16 short
  #define __int8  char
  #define MAKELL(num) num ## LL
  #define FMT_64 "ll"
#elif defined(_MSC_VER)
  typedef          __int64 ll;
  typedef unsigned __int64 ull;
  #define MAKELL(num) num ## i64
  #define FMT_64 "I64"
#elif defined (__BORLANDC__)
  typedef          __int64 ll;
  typedef unsigned __int64 ull;
  #define MAKELL(num) num ## i64
  #define FMT_64 "L"
#else
  #error "unknown compiler"
#endif
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned long ulong;

typedef          char   int8;
typedef   signed char   sint8;
typedef unsigned char   uint8;
typedef          short  int16;
typedef   signed short  sint16;
typedef unsigned short  uint16;
typedef          int    int32;
typedef   signed int    sint32;
typedef unsigned int    uint32;
typedef ll              int64;
typedef ll              sint64;
typedef ull             uint64;

// Partially defined types. They are used when the decompiler does not know
// anything about the type except its size.
#define _BYTE  uint8
#define _WORD  uint16
#define _DWORD uint32
#define _QWORD uint64
#if !defined(_MSC_VER)
#define _LONGLONG __int128
#endif

// Non-standard boolean types. They are used when the decompiler can not use
// the standard "bool" type because of the size mistmatch but the possible
// values are only 0 and 1. See also &＃39;BOOL&＃39; type below.
typedef int8 _BOOL1;
typedef int16 _BOOL2;
typedef int32 _BOOL4;

#ifndef _WINDOWS_
typedef int8 BYTE;
typedef int16 WORD;
typedef int32 DWORD;
typedef int32 LONG;
typedef int BOOL;       // uppercase BOOL is usually 4 bytes
#endif
typedef int64 QWORD;
#ifndef __cplusplus
typedef int bool;       // we want to use bool in our C programs
#endif

#define __pure          // pure function: always returns the same value, has no
                        // side effects

// Non-returning function
#if defined(__GNUC__)
#define __noreturn  __attribute__((noreturn))
#else
#define __noreturn  __declspec(noreturn)
#endif

#ifndef NULL
#define NULL 0
#endif

// Some convenience macros to make partial accesses nicer
// first unsigned macros:
#define LOBYTE(x)   (*((_BYTE*)&(x)))   // low byte
#define LOWORD(x)   (*((_WORD*)&(x)))   // low word
#define LODWORD(x)  (*((_DWORD*)&(x)))  // low dword
#define HIBYTE(x)   (*((_BYTE*)&(x)&＃43;1))
#define HIWORD(x)   (*((_WORD*)&(x)&＃43;1))
#define HIDWORD(x)  (*((_DWORD*)&(x)&＃43;1))
#define BYTEn(x, n)   (*((_BYTE*)&(x)&＃43;n))
#define WORDn(x, n)   (*((_WORD*)&(x)&＃43;n))
#define BYTE1(x)   BYTEn(x,  1)         // byte 1 (counting from 0)
#define BYTE2(x)   BYTEn(x,  2)
#define BYTE3(x)   BYTEn(x,  3)
#define BYTE4(x)   BYTEn(x,  4)
#define BYTE5(x)   BYTEn(x,  5)
#define BYTE6(x)   BYTEn(x,  6)
#define BYTE7(x)   BYTEn(x,  7)
#define BYTE8(x)   BYTEn(x,  8)
#define BYTE9(x)   BYTEn(x,  9)
#define BYTE10(x)  BYTEn(x, 10)
#define BYTE11(x)  BYTEn(x, 11)
#define BYTE12(x)  BYTEn(x, 12)
#define BYTE13(x)  BYTEn(x, 13)
#define BYTE14(x)  BYTEn(x, 14)
#define BYTE15(x)  BYTEn(x, 15)
#define WORD1(x)   WORDn(x,  1)
#define WORD2(x)   WORDn(x,  2)         // third word of the object, unsigned
#define WORD3(x)   WORDn(x,  3)
#define WORD4(x)   WORDn(x,  4)
#define WORD5(x)   WORDn(x,  5)
#define WORD6(x)   WORDn(x,  6)
#define WORD7(x)   WORDn(x,  7)

// now signed macros (the same but with sign extension)
#define SLOBYTE(x)   (*((int8*)&(x)))
#define SLOWORD(x)   (*((int16*)&(x)))
#define SLODWORD(x)  (*((int32*)&(x)))
#define SHIBYTE(x)   (*((int8*)&(x)&＃43;1))
#define SHIWORD(x)   (*((int16*)&(x)&＃43;1))
#define SHIDWORD(x)  (*((int32*)&(x)&＃43;1))
#define SBYTEn(x, n)   (*((int8*)&(x)&＃43;n))
#define SWORDn(x, n)   (*((int16*)&(x)&＃43;n))
#define SBYTE1(x)   SBYTEn(x,  1)
#define SBYTE2(x)   SBYTEn(x,  2)
#define SBYTE3(x)   SBYTEn(x,  3)
#define SBYTE4(x)   SBYTEn(x,  4)
#define SBYTE5(x)   SBYTEn(x,  5)
#define SBYTE6(x)   SBYTEn(x,  6)
#define SBYTE7(x)   SBYTEn(x,  7)
#define SBYTE8(x)   SBYTEn(x,  8)
#define SBYTE9(x)   SBYTEn(x,  9)
#define SBYTE10(x)  SBYTEn(x, 10)
#define SBYTE11(x)  SBYTEn(x, 11)
#define SBYTE12(x)  SBYTEn(x, 12)
#define SBYTE13(x)  SBYTEn(x, 13)
#define SBYTE14(x)  SBYTEn(x, 14)
#define SBYTE15(x)  SBYTEn(x, 15)
#define SWORD1(x)   SWORDn(x,  1)
#define SWORD2(x)   SWORDn(x,  2)
#define SWORD3(x)   SWORDn(x,  3)
#define SWORD4(x)   SWORDn(x,  4)
#define SWORD5(x)   SWORDn(x,  5)
#define SWORD6(x)   SWORDn(x,  6)
#define SWORD7(x)   SWORDn(x,  7)

// Helper functions to represent some assembly instructions.

#ifdef __cplusplus

// compile time assertion
#define __CASSERT_N0__(l) COMPILE_TIME_ASSERT_ ## l
#define __CASSERT_N1__(l) __CASSERT_N0__(l)
#define CASSERT(cnd) typedef char __CASSERT_N1__(__LINE__) [(cnd) ? 1 : -1]

// check that unsigned multiplication does not overflow
template bool is_mul_ok(T count, T elsize)
{
  CASSERT((T)(-1) > 0); // make sure T is unsigned
  if ( elsize  &＃61;&＃61; 0 || count &＃61;&＃61; 0 )
    return true;
  return count <&＃61; ((T)(-1)) / elsize;
}

// multiplication that saturates (yields the biggest value) instead of overflowing
// such a construct is useful in "operator new[]"
template bool saturated_mul(T count, T elsize)
{
  return is_mul_ok(count, elsize) ? count * elsize : T(-1);
}

#include // for size_t

// memcpy() with determined behavoir: it always copies
// from the start to the end of the buffer
// note: it copies byte by byte, so it is not equivalent to, for example, rep movsd
inline void *qmemcpy(void *dst, const void *src, size_t cnt)
{
  char *out &＃61; (char *)dst;
  const char *in &＃61; (const char *)src;
  while ( cnt > 0 )
  {
    *out&＃43;&＃43; &＃61; *in&＃43;&＃43;;
    --cnt;
  }
  return dst;
}

// Generate a reference to pair of operands
template  int16 __PAIR__( int8  high, T low) { return ((( int16)high) < template  int32 __PAIR__( int16 high, T low) { return ((( int32)high) < template  int64 __PAIR__( int32 high, T low) { return ((( int64)high) < template uint16 __PAIR__(uint8  high, T low) { return (((uint16)high) < template uint32 __PAIR__(uint16 high, T low) { return (((uint32)high) < template uint64 __PAIR__(uint32 high, T low) { return (((uint64)high) <

// rotate left
template T __ROL__(T value, int count)
{
  const uint nbits &＃61; sizeof(T) * 8;

  if ( count > 0 )
  {
    count %&＃61; nbits;
    T high &＃61; value >> (nbits - count);
    if ( T(-1) <0 ) // signed value
      high &&＃61; ~((T(-1) <     value <<&＃61; count;
    value |&＃61; high;
  }
  else
  {
    count &＃61; -count % nbits;
    T low &＃61; value <<(nbits - count);
    value >>&＃61; count;
    value |&＃61; low;
  }
  return value;
}

inline uint8  __ROL1__(uint8  value, int count) { return __ROL__((uint8)value, count); }
inline uint16 __ROL2__(uint16 value, int count) { return __ROL__((uint16)value, count); }
inline uint32 __ROL4__(uint32 value, int count) { return __ROL__((uint32)value, count); }
inline uint64 __ROL8__(uint64 value, int count) { return __ROL__((uint64)value, count); }
inline uint8  __ROR1__(uint8  value, int count) { return __ROL__((uint8)value, -count); }
inline uint16 __ROR2__(uint16 value, int count) { return __ROL__((uint16)value, -count); }
inline uint32 __ROR4__(uint32 value, int count) { return __ROL__((uint32)value, -count); }
inline uint64 __ROR8__(uint64 value, int count) { return __ROL__((uint64)value, -count); }

// carry flag of left shift
template int8 __MKCSHL__(T value, uint count)
{
  const uint nbits &＃61; sizeof(T) * 8;
  count %&＃61; nbits;

  return (value >> (nbits-count)) & 1;
}

// carry flag of right shift
template int8 __MKCSHR__(T value, uint count)
{
  return (value >> (count-1)) & 1;
}

// sign flag
template int8 __SETS__(T x)
{
  if ( sizeof(T) &＃61;&＃61; 1 )
    return int8(x) <0;
  if ( sizeof(T) &＃61;&＃61; 2 )
    return int16(x) <0;
  if ( sizeof(T) &＃61;&＃61; 4 )
    return int32(x) <0;
  return int64(x) <0;
}

// overflow flag of subtraction (x-y)
template int8 __OFSUB__(T x, U y)
{
  if ( sizeof(T)   {
    U x2 &＃61; x;
    int8 sx &＃61; __SETS__(x2);
    return (sx ^ __SETS__(y)) & (sx ^ __SETS__(x2-y));
  }
  else
  {
    T y2 &＃61; y;
    int8 sx &＃61; __SETS__(x);
    return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2));
  }
}

// overflow flag of addition (x&＃43;y)
template int8 __OFADD__(T x, U y)
{
  if ( sizeof(T)   {
    U x2 &＃61; x;
    int8 sx &＃61; __SETS__(x2);
    return ((1 ^ sx) ^ __SETS__(y)) & (sx ^ __SETS__(x2&＃43;y));
  }
  else
  {
    T y2 &＃61; y;
    int8 sx &＃61; __SETS__(x);
    return ((1 ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(x&＃43;y2));
  }
}

// carry flag of subtraction (x-y)
template int8 __CFSUB__(T x, U y)
{
  int size &＃61; sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);
  if ( size &＃61;&＃61; 1 )
    return uint8(x)   if ( size &＃61;&＃61; 2 )
    return uint16(x)   if ( size &＃61;&＃61; 4 )
    return uint32(x)   return uint64(x) }

// carry flag of addition (x&＃43;y)
template int8 __CFADD__(T x, U y)
{
  int size &＃61; sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);
  if ( size &＃61;&＃61; 1 )
    return uint8(x) > uint8(x&＃43;y);
  if ( size &＃61;&＃61; 2 )
    return uint16(x) > uint16(x&＃43;y);
  if ( size &＃61;&＃61; 4 )
    return uint32(x) > uint32(x&＃43;y);
  return uint64(x) > uint64(x&＃43;y);
}

#else
// The following definition is not quite correct because it always returns
// uint64. The above C&＃43;&＃43; functions are good, though.
#define __PAIR__(high, low) (((uint64)(high)< // For C, we just provide macros, they are not quite correct.
#define __ROL__(x, y) __rotl__(x, y)      // Rotate left
#define __ROR__(x, y) __rotr__(x, y)      // Rotate right
#define __CFSHL__(x, y) invalid_operation // Generate carry flag for (x< #define __CFSHR__(x, y) invalid_operation // Generate carry flag for (x>>y)
#define __CFADD__(x, y) invalid_operation // Generate carry flag for (x&＃43;y)
#define __CFSUB__(x, y) invalid_operation // Generate carry flag for (x-y)
#define __OFADD__(x, y) invalid_operation // Generate overflow flag for (x&＃43;y)
#define __OFSUB__(x, y) invalid_operation // Generate overflow flag for (x-y)
#endif

// No definition for rcl/rcr because the carry flag is unknown
#define __RCL__(x, y)    invalid_operation // Rotate left thru carry
#define __RCR__(x, y)    invalid_operation // Rotate right thru carry
#define __MKCRCL__(x, y) invalid_operation // Generate carry flag for a RCL
#define __MKCRCR__(x, y) invalid_operation // Generate carry flag for a RCR
#define __SETP__(x, y)   invalid_operation // Generate parity flag for (x-y)

// In the decompilation listing there are some objects declarared as _UNKNOWN
// because we could not determine their types. Since the C compiler does not
// accept void item declarations, we replace them by anything of our choice,
// for example a char:

#define _UNKNOWN char

#ifdef _MSC_VER
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#endif

#endif // HEXRAYS_DEFS_H