1 /* 2 3 This file contains definitions used by the Hex-Rays decompiler output. 4 It has type definitions and convenience macros to make the 5 output more readable. 6 7 Copyright (c) 2007-2011 Hex-Rays 8 9 */ 10 11 #if defined(__GNUC__) 12 typedef long long ll; 13 typedef unsigned long long ull; 14 #define __int64 long long 15 #define __int32 int 16 #define __int16 short 17 #define __int8 char 18 #define MAKELL(num) num ## LL 19 #define FMT_64 "ll" 20 #elif defined(_MSC_VER) 21 typedef __int64 ll; 22 typedef unsigned __int64 ull; 23 #define MAKELL(num) num ## i64 24 #define FMT_64 "I64" 25 #elif defined (__BORLANDC__) 26 typedef __int64 ll; 27 typedef unsigned __int64 ull; 28 #define MAKELL(num) num ## i64 29 #define FMT_64 "L" 30 #else 31 #error "unknown compiler" 32 #endif 33 typedef unsigned int uint; 34 typedef unsigned char uchar; 35 typedef unsigned short ushort; 36 typedef unsigned long ulong; 37 38 typedef char int8; 39 typedef signed char sint8; 40 typedef unsigned char uint8; 41 typedef short int16; 42 typedef signed short sint16; 43 typedef unsigned short uint16; 44 typedef int int32; 45 typedef signed int sint32; 46 typedef unsigned int uint32; 47 typedef ll int64; 48 typedef ll sint64; 49 typedef ull uint64; 50 51 // Partially defined types: 52 #define _BYTE uint8 53 #define _WORD uint16 54 #define _DWORD uint32 55 #define _QWORD uint64 56 #if !defined(_MSC_VER) 57 #define _LONGLONG __int128 58 #endif 59 60 #ifndef _WINDOWS_ 61 typedef int8 BYTE; 62 typedef int16 WORD; 63 typedef int32 DWORD; 64 typedef int32 LONG; 65 #endif 66 typedef int64 QWORD; 67 #ifndef __cplusplus 68 typedef int bool; // we want to use bool in our C programs 69 #endif 70 71 // Some convenience macros to make partial accesses nicer 72 // first unsigned macros: 73 #define LOBYTE(x) (*((_BYTE*)&(x))) // low byte 74 #define LOWORD(x) (*((_WORD*)&(x))) // low word 75 #define LODWORD(x) (*((_DWORD*)&(x))) // low dword 76 #define HIBYTE(x) (*((_BYTE*)&(x)+1)) 77 #define HIWORD(x) (*((_WORD*)&(x)+1)) 78 #define HIDWORD(x) (*((_DWORD*)&(x)+1)) 79 #define BYTEn(x, n) (*((_BYTE*)&(x)+n)) 80 #define WORDn(x, n) (*((_WORD*)&(x)+n)) 81 #define BYTE1(x) BYTEn(x, 1) // byte 1 (counting from 0) 82 #define BYTE2(x) BYTEn(x, 2) 83 #define BYTE3(x) BYTEn(x, 3) 84 #define BYTE4(x) BYTEn(x, 4) 85 #define BYTE5(x) BYTEn(x, 5) 86 #define BYTE6(x) BYTEn(x, 6) 87 #define BYTE7(x) BYTEn(x, 7) 88 #define BYTE8(x) BYTEn(x, 8) 89 #define BYTE9(x) BYTEn(x, 9) 90 #define BYTE10(x) BYTEn(x, 10) 91 #define BYTE11(x) BYTEn(x, 11) 92 #define BYTE12(x) BYTEn(x, 12) 93 #define BYTE13(x) BYTEn(x, 13) 94 #define BYTE14(x) BYTEn(x, 14) 95 #define BYTE15(x) BYTEn(x, 15) 96 #define WORD1(x) WORDn(x, 1) 97 #define WORD2(x) WORDn(x, 2) // third word of the object, unsigned 98 #define WORD3(x) WORDn(x, 3) 99 #define WORD4(x) WORDn(x, 4) 100 #define WORD5(x) WORDn(x, 5) 101 #define WORD6(x) WORDn(x, 6) 102 #define WORD7(x) WORDn(x, 7) 103 104 // now signed macros (the same but with sign extension) 105 #define SLOBYTE(x) (*((int8*)&(x))) 106 #define SLOWORD(x) (*((int16*)&(x))) 107 #define SLODWORD(x) (*((int32*)&(x))) 108 #define SHIBYTE(x) (*((int8*)&(x)+1)) 109 #define SHIWORD(x) (*((int16*)&(x)+1)) 110 #define SHIDWORD(x) (*((int32*)&(x)+1)) 111 #define SBYTEn(x, n) (*((int8*)&(x)+n)) 112 #define SWORDn(x, n) (*((int16*)&(x)+n)) 113 #define SBYTE1(x) SBYTEn(x, 1) 114 #define SBYTE2(x) SBYTEn(x, 2) 115 #define SBYTE3(x) SBYTEn(x, 3) 116 #define SBYTE4(x) SBYTEn(x, 4) 117 #define SBYTE5(x) SBYTEn(x, 5) 118 #define SBYTE6(x) SBYTEn(x, 6) 119 #define SBYTE7(x) SBYTEn(x, 7) 120 #define SBYTE8(x) SBYTEn(x, 8) 121 #define SBYTE9(x) SBYTEn(x, 9) 122 #define SBYTE10(x) SBYTEn(x, 10) 123 #define SBYTE11(x) SBYTEn(x, 11) 124 #define SBYTE12(x) SBYTEn(x, 12) 125 #define SBYTE13(x) SBYTEn(x, 13) 126 #define SBYTE14(x) SBYTEn(x, 14) 127 #define SBYTE15(x) SBYTEn(x, 15) 128 #define SWORD1(x) SWORDn(x, 1) 129 #define SWORD2(x) SWORDn(x, 2) 130 #define SWORD3(x) SWORDn(x, 3) 131 #define SWORD4(x) SWORDn(x, 4) 132 #define SWORD5(x) SWORDn(x, 5) 133 #define SWORD6(x) SWORDn(x, 6) 134 #define SWORD7(x) SWORDn(x, 7) 135 136 137 // Helper functions to represent some assembly instructions. 138 139 #ifdef __cplusplus 140 141 // Fill memory block with an integer value 142 inline void memset32(void *ptr, uint32 value, int count) 143 { 144 uint32 *p = (uint32 *)ptr; 145 for ( int i=0; i < count; i++ ) 146 *p++ = value; 147 } 148 149 // Generate a reference to pair of operands 150 template<class T> int16 __PAIR__( int8 high, T low) { return ((( int16)high) << sizeof(high)*8) | uint8(low); } 151 template<class T> int32 __PAIR__( int16 high, T low) { return ((( int32)high) << sizeof(high)*8) | uint16(low); } 152 template<class T> int64 __PAIR__( int32 high, T low) { return ((( int64)high) << sizeof(high)*8) | uint32(low); } 153 template<class T> uint16 __PAIR__(uint8 high, T low) { return (((uint16)high) << sizeof(high)*8) | uint8(low); } 154 template<class T> uint32 __PAIR__(uint16 high, T low) { return (((uint32)high) << sizeof(high)*8) | uint16(low); } 155 template<class T> uint64 __PAIR__(uint32 high, T low) { return (((uint64)high) << sizeof(high)*8) | uint32(low); } 156 157 // rotate left 158 template<class T> T __ROL__(T value, uint count) 159 { 160 const uint nbits = sizeof(T) * 8; 161 count %= nbits; 162 163 T high = value >> (nbits - count); 164 value <<= count; 165 value |= high; 166 return value; 167 } 168 169 // rotate right 170 template<class T> T __ROR__(T value, uint count) 171 { 172 const uint nbits = sizeof(T) * 8; 173 count %= nbits; 174 175 T low = value << (nbits - count); 176 value >>= count; 177 value |= low; 178 return value; 179 } 180 181 // carry flag of left shift 182 template<class T> int8 __MKCSHL__(T value, uint count) 183 { 184 const uint nbits = sizeof(T) * 8; 185 count %= nbits; 186 187 return (value >> (nbits-count)) & 1; 188 } 189 190 // carry flag of right shift 191 template<class T> int8 __MKCSHR__(T value, uint count) 192 { 193 return (value >> (count-1)) & 1; 194 } 195 196 // sign flag 197 template<class T> int8 __SETS__(T x) 198 { 199 if ( sizeof(T) == 1 ) 200 return int8(x) < 0; 201 if ( sizeof(T) == 2 ) 202 return int16(x) < 0; 203 if ( sizeof(T) == 4 ) 204 return int32(x) < 0; 205 return int64(x) < 0; 206 } 207 208 // overflow flag of subtraction (x-y) 209 template<class T, class U> int8 __OFSUB__(T x, U y) 210 { 211 if ( sizeof(T) < sizeof(U) ) 212 { 213 U x2 = x; 214 int8 sx = __SETS__(x2); 215 return (sx ^ __SETS__(y)) & (sx ^ __SETS__(x2-y)); 216 } 217 else 218 { 219 T y2 = y; 220 int8 sx = __SETS__(x); 221 return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(x-y2)); 222 } 223 } 224 225 // overflow flag of addition (x+y) 226 template<class T, class U> int8 __OFADD__(T x, U y) 227 { 228 if ( sizeof(T) < sizeof(U) ) 229 { 230 U x2 = x; 231 int8 sx = __SETS__(x2); 232 return ((1 ^ sx) ^ __SETS__(y)) & (sx ^ __SETS__(x2+y)); 233 } 234 else 235 { 236 T y2 = y; 237 int8 sx = __SETS__(x); 238 return ((1 ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(x+y2)); 239 } 240 } 241 242 // carry flag of subtraction (x-y) 243 template<class T, class U> int8 __CFSUB__(T x, U y) 244 { 245 int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U); 246 if ( size == 1 ) 247 return uint8(x) < uint8(y); 248 if ( size == 2 ) 249 return uint16(x) < uint16(y); 250 if ( size == 4 ) 251 return uint32(x) < uint32(y); 252 return uint64(x) < uint64(y); 253 } 254 255 // carry flag of addition (x+y) 256 template<class T, class U> int8 __CFADD__(T x, U y) 257 { 258 int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U); 259 if ( size == 1 ) 260 return uint8(x) > uint8(x+y); 261 if ( size == 2 ) 262 return uint16(x) > uint16(x+y); 263 if ( size == 4 ) 264 return uint32(x) > uint32(x+y); 265 return uint64(x) > uint64(x+y); 266 } 267 268 #else 269 // The following definition is not quite correct because it always returns 270 // uint64. The above C++ functions are good, though. 271 #define __PAIR__(high, low) (((uint64)(high)<<sizeof(high)*8) | low) 272 // For C, we just provide macros, they are not quite correct. 273 #define __ROL__(x, y) __rotl__(x, y) // Rotate left 274 #define __ROR__(x, y) __rotr__(x, y) // Rotate right 275 #define __CFSHL__(x, y) invalid_operation // Generate carry flag for (x<<y) 276 #define __CFSHR__(x, y) invalid_operation // Generate carry flag for (x>>y) 277 #define __CFADD__(x, y) invalid_operation // Generate carry flag for (x+y) 278 #define __CFSUB__(x, y) invalid_operation // Generate carry flag for (x-y) 279 #define __OFADD__(x, y) invalid_operation // Generate overflow flag for (x+y) 280 #define __OFSUB__(x, y) invalid_operation // Generate overflow flag for (x-y) 281 #endif 282 283 // No definition for rcl/rcr because the carry flag is unknown 284 #define __RCL__(x, y) invalid_operation // Rotate left thru carry 285 #define __RCR__(x, y) invalid_operation // Rotate right thru carry 286 #define __MKCRCL__(x, y) invalid_operation // Generate carry flag for a RCL 287 #define __MKCRCR__(x, y) invalid_operation // Generate carry flag for a RCR 288 #define __SETP__(x, y) invalid_operation // Generate parity flag for (x-y) 289 290 // In the decompilation listing there are some objects declarared as _UNKNOWN 291 // because we could not determine their types. Since the C compiler does not 292 // accept void item declarations, we replace them by anything of our choice, 293 // for example a char: 294 295 #define _UNKNOWN char 296 297 #ifdef _MSC_VER 298 #define snprintf _snprintf 299 #define vsnprintf _vsnprintf 300 #endif