튜기's blogggg

IDA Pro plug-in defines

by St1tch

Memo

/*


   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-2011 Hex-Rays


*/


#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:

#define _BYTE  uint8

#define _WORD  uint16

#define _DWORD uint32

#define _QWORD uint64

#if !defined(_MSC_VER)

#define _LONGLONG __int128

#endif


#ifndef _WINDOWS_

typedef int8 BYTE;

typedef int16 WORD;

typedef int32 DWORD;

typedef int32 LONG;

#endif

typedef int64 QWORD;

#ifndef __cplusplus

typedef int bool;       // we want to use bool in our C programs

#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)+1))

#define HIWORD(x)   (*((_WORD*)&(x)+1))

#define HIDWORD(x)  (*((_DWORD*)&(x)+1))

#define BYTEn(x, n)   (*((_BYTE*)&(x)+n))

#define WORDn(x, n)   (*((_WORD*)&(x)+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)+1))

#define SHIWORD(x)   (*((int16*)&(x)+1))

#define SHIDWORD(x)  (*((int32*)&(x)+1))

#define SBYTEn(x, n)   (*((int8*)&(x)+n))

#define SWORDn(x, n)   (*((int16*)&(x)+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


// Fill memory block with an integer value

inline void memset32(void *ptr, uint32 value, int count)

{

  uint32 *p = (uint32 *)ptr;

  for ( int i=0; i < count; i++ )

    *p++ = value;

}


// Generate a reference to pair of operands

template<class T>  int16 __PAIR__( int8  high, T low) { return ((( int16)high) << sizeof(high)*8) | uint8(low); }

template<class T>  int32 __PAIR__( int16 high, T low) { return ((( int32)high) << sizeof(high)*8) | uint16(low); }

template<class T>  int64 __PAIR__( int32 high, T low) { return ((( int64)high) << sizeof(high)*8) | uint32(low); }

template<class T> uint16 __PAIR__(uint8  high, T low) { return (((uint16)high) << sizeof(high)*8) | uint8(low); }

template<class T> uint32 __PAIR__(uint16 high, T low) { return (((uint32)high) << sizeof(high)*8) | uint16(low); }

template<class T> uint64 __PAIR__(uint32 high, T low) { return (((uint64)high) << sizeof(high)*8) | uint32(low); }


// rotate left

template<class T> T __ROL__(T value, uint count)

{

  const uint nbits = sizeof(T) * 8;

  count %= nbits;


  T high = value >> (nbits - count);

  value <<= count;

  value |= high;

  return value;

}


// rotate right

template<class T> T __ROR__(T value, uint count)

{

  const uint nbits = sizeof(T) * 8;

  count %= nbits;


  T low = value << (nbits - count);

  value >>= count;

  value |= low;

  return value;

}


// carry flag of left shift

template<class T> int8 __MKCSHL__(T value, uint count)

{

  const uint nbits = sizeof(T) * 8;

  count %= nbits;


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

}


// carry flag of right shift

template<class T> int8 __MKCSHR__(T value, uint count)

{

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

}


// sign flag

template<class T> int8 __SETS__(T x)

{

  if ( sizeof(T) == 1 )

    return int8(x) < 0;

  if ( sizeof(T) == 2 )

    return int16(x) < 0;

  if ( sizeof(T) == 4 )

    return int32(x) < 0;

  return int64(x) < 0;

}


// overflow flag of subtraction (x-y)

template<class T, class U> int8 __OFSUB__(T x, U y)

{

  if ( sizeof(T) < sizeof(U) )

  {

    U x2 = x;

    int8 sx = __SETS__(x2);

    return (sx ^ __SETS__(y)) & (sx ^ __SETS__(x2-y));

  }

  else

  {

    T y2 = y;

    int8 sx = __SETS__(x);

    return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2));

  }

}


// overflow flag of addition (x+y)

template<class T, class U> int8 __OFADD__(T x, U y)

{

  if ( sizeof(T) < sizeof(U) )

  {

    U x2 = x;

    int8 sx = __SETS__(x2);

    return ((1 ^ sx) ^ __SETS__(y)) & (sx ^ __SETS__(x2+y));

  }

  else

  {

    T y2 = y;

    int8 sx = __SETS__(x);

    return ((1 ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(x+y2));

  }

}


// carry flag of subtraction (x-y)

template<class T, class U> int8 __CFSUB__(T x, U y)

{

  int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);

  if ( size == 1 )

    return uint8(x) < uint8(y);

  if ( size == 2 )

    return uint16(x) < uint16(y);

  if ( size == 4 )

    return uint32(x) < uint32(y);

  return uint64(x) < uint64(y);

}


// carry flag of addition (x+y)

template<class T, class U> int8 __CFADD__(T x, U y)

{

  int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);

  if ( size == 1 )

    return uint8(x) > uint8(x+y);

  if ( size == 2 )

    return uint16(x) > uint16(x+y);

  if ( size == 4 )

    return uint32(x) > uint32(x+y);

  return uint64(x) > uint64(x+y);

}


#else

// The following definition is not quite correct because it always returns

// uint64. The above C++ functions are good, though.

#define __PAIR__(high, low) (((uint64)(high)<<sizeof(high)*8) | low)

// 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<<y)

#define __CFSHR__(x, y) invalid_operation // Generate carry flag for (x>>y)

#define __CFADD__(x, y) invalid_operation // Generate carry flag for (x+y)

#define __CFSUB__(x, y) invalid_operation // Generate carry flag for (x-y)

#define __OFADD__(x, y) invalid_operation // Generate overflow flag for (x+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

저작자표시

블로그의 정보

튜기's blogg(st1tch)

St1tch

활동하기

티스토리툴바