Update defs.h to newer version

Dockerfile

@@ -9,6 +9,8 @@ RUN chmod -R og+rX /root/miniconda3
 
 RUN git clone https://github.com/lt-asset/resym /home/ReSym
 
+COPY ./defs.h /home/ReSym/clang-parser/defs.hh
+
 WORKDIR /code
 
 # Set up a new user named "user" with user ID 1000

defs.h

@@ -0,0 +1,442 @@
+/*
+
+   This file contains definitions used in the Hex-Rays decompiler output.
+   It has type definitions and convenience macros to make the
+   output more readable.
+
+   Copyright (c) 2007-2024 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 cannot 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;
+typedef int64 _BOOL8;
+
+#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:
+                // when given the same arguments, 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
+#define LAST_IND(x,part_type)    (sizeof(x)/sizeof(part_type) - 1)
+#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN
+#  define LOW_IND(x,part_type)   LAST_IND(x,part_type)
+#  define HIGH_IND(x,part_type)  0
+#else
+#  define HIGH_IND(x,part_type)  LAST_IND(x,part_type)
+#  define LOW_IND(x,part_type)   0
+#endif
+// first unsigned macros:
+#define BYTEn(x, n)   (*((_BYTE*)&(x)+n))
+#define WORDn(x, n)   (*((_WORD*)&(x)+n))
+#define DWORDn(x, n)  (*((_DWORD*)&(x)+n))
+
+#define LOBYTE(x)  BYTEn(x,LOW_IND(x,_BYTE))
+#define LOWORD(x)  WORDn(x,LOW_IND(x,_WORD))
+#define LODWORD(x) DWORDn(x,LOW_IND(x,_DWORD))
+#define HIBYTE(x)  BYTEn(x,HIGH_IND(x,_BYTE))
+#define HIWORD(x)  WORDn(x,HIGH_IND(x,_WORD))
+#define HIDWORD(x) DWORDn(x,HIGH_IND(x,_DWORD))
+#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 SBYTEn(x, n)   (*((int8*)&(x)+n))
+#define SWORDn(x, n)   (*((int16*)&(x)+n))
+#define SDWORDn(x, n)  (*((int32*)&(x)+n))
+
+#define SLOBYTE(x)  SBYTEn(x,LOW_IND(x,int8))
+#define SLOWORD(x)  SWORDn(x,LOW_IND(x,int16))
+#define SLODWORD(x) SDWORDn(x,LOW_IND(x,int32))
+#define SHIBYTE(x)  SBYTEn(x,HIGH_IND(x,int8))
+#define SHIWORD(x)  SWORDn(x,HIGH_IND(x,int16))
+#define SHIDWORD(x) SDWORDn(x,HIGH_IND(x,int32))
+#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)
+
+// Generate a pair of operands. S stands for 'signed'
+#define __SPAIR16__(high, low)  (((int16)  (high) <<  8) | (uint8) (low))
+#define __SPAIR32__(high, low)  (((int32)  (high) << 16) | (uint16)(low))
+#define __SPAIR64__(high, low)  (((int64)  (high) << 32) | (uint32)(low))
+#define __SPAIR128__(high, low) (((int128) (high) << 64) | (uint64)(low))
+#define __PAIR16__(high, low)   (((uint16) (high) <<  8) | (uint8) (low))
+#define __PAIR32__(high, low)   (((uint32) (high) << 16) | (uint16)(low))
+#define __PAIR64__(high, low)   (((uint64) (high) << 32) | (uint32)(low))
+#define __PAIR128__(high, low)  (((uint128)(high) << 64) | (uint64)(low))
+
+// 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;
+}
+
+// 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); }
+
+// 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__(U(x2-y)));
+  }
+  else
+  {
+    T y2 = y;
+    int8 sx = __SETS__(x);
+    return (sx ^ __SETS__(y2)) & (sx ^ __SETS__(T(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__(U(x2+y)));
+  }
+  else
+  {
+    T y2 = y;
+    int8 sx = __SETS__(x);
+    return ((1 ^ sx) ^ __SETS__(y2)) & (sx ^ __SETS__(T(x+y2)));
+  }
+}
+
+// https://en.wikipedia.org/wiki/Carry_flag#Carry_flag_vs._borrow_flag
+#if defined(__ARM__) || defined(__PPC__)
+#define SUB_WITH_CARRY 1
+#else
+#define SUB_WITH_CARRY 0
+#endif
+
+// 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);
+  bool res;
+  if ( size == 1 )
+    res = uint8(x) < uint8(y);
+  else if ( size == 2 )
+    res = uint16(x) < uint16(y);
+  else if ( size == 4 )
+    res = uint32(x) < uint32(y);
+  else
+    res = uint64(x) < uint64(y);
+#if SUB_WITH_CARRY
+  res = !res;
+#endif
+  return res;
+}
+
+// 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);
+}
+
+// carry flag of subtraction with carry
+template<class T, class U> int8 __CFSUB__(T x, U y, int8 cf)
+{
+#if SUB_WITH_CARRY
+  cf = !cf;
+#endif
+  return __CFADD__(y, cf) ^ __CFSUB(x, y + cf);
+}
+
+// overflow flag of subtraction with carry
+template<class T, class U> int8 __OFSUB__(T x, U y, int8 cf)
+{
+#if SUB_WITH_CARRY
+  cf = !cf;
+#endif
+  return __OFADD__(y, cf) ^ __OFSUB(x, y + cf);
+}
+
+inline uint8   abs8(int8     x) { return x >= 0 ? x : -x; }
+inline uint16  abs16(int16   x) { return x >= 0 ? x : -x; }
+inline uint32  abs32(int32   x) { return x >= 0 ? x : -x; }
+inline uint64  abs64(int64   x) { return x >= 0 ? x : -x; }
+//inline uint128 abs128(int128 x) { return x >= 0 ? x : -x; }
+
+#include <string.h>     // for memcpy
+#include <type_traits>  // for enable_if
+
+template <typename T, typename F>
+inline typename std::enable_if<sizeof(T) <= sizeof(F), T>::type __coerce(F f)
+{
+  T t;
+  memcpy(&t, &f, sizeof(T));
+  return t;
+}
+#define COERCE_FLOAT(v) __coerce<float>(v)
+#define COERCE_DOUBLE(v) __coerce<double>(v)
+#define COERCE_LONG_DOUBLE(v) __coerce<long double>(v)
+#define COERCE_UNSIGNED_INT(v) __coerce<unsigned int>(v)
+#define COERCE_UNSIGNED_INT64(v) __coerce<uint64>(v)
+
+#else // C++
+// 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)
+
+#define abs8(x)   (int8)  ((int8)  (x) >= 0 ? (x) : -(x))
+#define abs16(x)  (int16) ((int16) (x) >= 0 ? (x) : -(x))
+#define abs32(x)  (int32) ((int32) (x) >= 0 ? (x) : -(x))
+#define abs64(x)  (int64) ((int64) (x) >= 0 ? (x) : -(x))
+#define abs128(x) (int128)((int128)(x) >= 0 ? (x) : -(x))
+
+#endif // C++
+
+#if defined(__MIPS__)
+// traps for MIPS arithmetic operation
+void __noreturn __integer_oveflow(void); // SIGFPE/FPE_INTOVF
+void __noreturn __divide_by_zero(void);  // SIGFPE/FPE_INTDIV
+void __noreturn __trap(uint16 trapcode); // SIGTRAP
+void __noreturn __break(uint16 code, uint16 subcode);
+#endif
+
+#define __SETP__(x, y)   invalid_operation // Generate parity flag for (x-y)
+
+// In the decompilation listing there are some objects declared 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
+
+// The ADJ() macro is used for shifted pointers.
+// While compilers do not understand it, it makes the code more readable.
+// A shifted pointer is declared like this, for example:
+//      char *__shifted(mystruct,8) p;
+// It means: while 'p' points to 'char', it also points to the middle of 'mystruct'.
+// More precisely, it is at the offset of 8 bytes from the beginning of 'mystruct'.
+//
+// The ADJ() macro performs the necessary adjustment.
+// The __parentof() and __deltaof() functions are made up, they do not exist.
+// __parentof() returns the parent structure type.
+// __deltaof() returns the shift amount.
+
+#define ADJ(p) (__parentof(p) *)(p-__deltaof(p))
+
+#endif // HEXRAYS_DEFS_H