defs.h

/*

   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-2014 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 'BOOL' type below.
	typedef int8 _BOOL1;
	typedef int16 _BOOL2;
	typedef int32 _BOOL4;

	#ifndef _WINDOWS_TYPES
		#ifndef __WIN32__
			typedef int8 BYTE;
			typedef int16 WORD;
			typedef int32 DWORD;
			typedef int32 LONG;
			typedef int BOOL;       // uppercase BOOL is usually 4 bytes
		#endif
	#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)+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

	// 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<class T> bool is_mul_ok(T count, T elsize)
	{
	  CASSERT((T)(-1) > 0); // make sure T is unsigned
	  if ( elsize  == 0 || count == 0 )
		return true;
	  return count <= ((T)(-1)) / elsize;
	}

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

	#include <stddef.h> // 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 = (char *)dst;
	  const char *in = (const char *)src;
	  while ( cnt > 0 )
	  {
		*out++ = *in++;
		--cnt;
	  }
	  return dst;
	}

	// 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, int count)
	{
	  const uint nbits = sizeof(T) * 8;

	  if ( count > 0 )
	  {
		count %= nbits;
		T high = value >> (nbits - count);
		if ( T(-1) < 0 ) // signed value
		  high &= ~((T(-1) << count));
		value <<= count;
		value |= high;
	  }
	  else
	  {
		count = -count % nbits;
		T low = value << (nbits - count);
		value >>= count;
		value |= 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
	 int8 __MKCSHL__(int value, uint count)
	{
	  const uint nbits = sizeof(int) * 8;
	  count %= nbits;

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

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

	// sign flag
	int8 __SETS__(int x)
	{
	  if ( sizeof(int) == 1 )
		return int8(x) < 0;
	  if ( sizeof(int) == 2 )
		return int16(x) < 0;
	  if ( sizeof(int) == 4 )
		return int32(x) < 0;
	  return int64(x) < 0;
	}

	// overflow flag of subtraction (x-y)
	 int8 __OFSUB__(int x, int y)
	{
 
		int y2 = y;
		int8 sx = __SETS__(x);
		return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2));
  
	}

	// overflow flag of addition (x+y)
	 int8 __OFADD__(int x, int y)
	{
  
		int y2 = y;
		int8 sx = __SETS__(x);
		return ((1 ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(x+y2));
  
	}

	// carry flag of subtraction (x-y)
	 int8 __CFSUB__(int x,int y)
	{
	  int size = sizeof(int) > sizeof(int) ? sizeof(int) : sizeof(int);
	  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)
	int8 __CFADD__(int x, int y)
	{
	  int size = sizeof(int) > sizeof(int) ? sizeof(int) : sizeof(int);
	  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)

	#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