@memoryprocess/bindings 0.0.0-stage → 0.0.1

package/native/hde/hde64.c

@@ -0,0 +1,538 @@
+/*
+ * Hacker Disassembler Engine 64 C
+ * Copyright (c) 2008-2009, Vyacheslav Patkov.
+ * All rights reserved.
+ *
+ */
+
+#if defined(_M_X64) || defined(__x86_64__)
+
+#include <string.h>
+#include "hde64.h"
+#include "table64.h"
+
+/* An instruction is at most 15 bytes long, so the bytes past that may not be
+ * mapped: a decode that would run over the limit stops instead of reading. */
+#define NEED(n) do { if (limit - p < (n)) goto error_length; } while (0)
+
+unsigned int hde64_disasm(const void *code, hde64s *hs)
+{
+    uint8_t x, c, *p = (uint8_t *)code, cflags, opcode, pref = 0, mand = 0;
+    uint8_t map0f = 0;          /* the opcode came from the 0F map */
+    uint8_t *ht = hde64_table, m_mod, m_reg, m_rm, disp_size = 0;
+    uint8_t op64 = 0, rex = 0, rex2 = 0, have_rex2 = 0, ext = 0;
+    uint8_t *limit = (uint8_t *)code + 15;
+
+    memset(hs, 0, sizeof(hde64s));
+
+    for (x = 15; x; x--)
+        switch (c = *p++) {
+            case 0xf3:
+                hs->p_rep = c;
+                pref |= PRE_F3;
+                mand = PRE_F3;
+                rex = 0;
+                break;
+            case 0xf2:
+                hs->p_rep = c;
+                pref |= PRE_F2;
+                mand = PRE_F2;
+                rex = 0;
+                break;
+            case 0xf0:
+                hs->p_lock = c;
+                pref |= PRE_LOCK;
+                rex = 0;
+                break;
+            case 0x26: case 0x2e: case 0x36:
+            case 0x3e: case 0x64: case 0x65:
+                hs->p_seg = c;
+                pref |= PRE_SEG;
+                rex = 0;
+                break;
+            case 0x66:
+                hs->p_66 = c;
+                pref |= PRE_66;
+                if (!mand)
+                    mand = PRE_66;
+                rex = 0;
+                break;
+            case 0x67:
+                hs->p_67 = c;
+                pref |= PRE_67;
+                rex = 0;
+                break;
+            default:
+                if ((c & 0xf0) != 0x40)
+                    goto pref_done;
+                /* REX counts only as the last prefix before the opcode: a
+                 * legacy prefix after it, or a further REX, discards it. */
+                rex = c;
+                break;
+        }
+    goto error_length;          /* 15 prefixes leave no room for an opcode */
+
+  pref_done:
+
+    hs->flags = (uint32_t)pref << 23;
+
+    if (!pref)
+        pref |= PRE_NONE;
+    /* pref says which prefix classes are present, which is what an
+     * operand-size or LOCK rule asks. A mandatory prefix is a choice
+     * between 66, F2 and F3 rather than a set, so the rules that select
+     * an instruction read mand instead. */
+    if (!mand)
+        mand = PRE_NONE;
+
+    if (rex) {
+        hs->flags |= F_PREFIX_REX;
+        hs->rex = rex;
+        hs->rex_w = (rex & 0xf) >> 3;
+        hs->rex_r = (rex & 7) >> 2;
+        hs->rex_x = (rex & 3) >> 1;
+        hs->rex_b = rex & 1;
+        if (hs->rex_w && (c & 0xf8) == 0xb8)
+            op64++;
+    }
+
+    /* VEX, EVEX and XOP. C4, C5 and 62 are always escapes in long mode; 8F is
+     * one only from map 8 upwards, which leaves 8F /0 as POP. The header names
+     * the opcode map, the map decides the immediate, and every instruction
+     * reached this way has a ModR/M byte. */
+    if (c == 0xc4 || c == 0xc5 || c == 0x62 ||
+        (c == 0x8f && p < limit && (*p & 0x1f) >= 8)) {
+        uint8_t map;
+
+        hs->opcode = c;
+        if (c == 0xc5) {
+            NEED(3);
+            map = 1;
+            p++;
+        } else if (c == 0x62) {
+            NEED(5);
+            map = *p & 0x07;            /* the bit above the map is APX's B4 */
+            p += 3;
+        } else {
+            NEED(4);
+            map = *p & 0x1f;
+            p += 2;
+        }
+        hs->opcode2 = opcode = *p++;
+
+        /* The escape carries the operand size and the register extensions
+         * itself, so a 66, F2, F3, LOCK or REX in front of it is invalid. A
+         * segment or 67 prefix still applies. */
+        if (rex || (pref & (PRE_66 | PRE_F2 | PRE_F3 | PRE_LOCK)))
+            hs->flags |= F_ERROR | F_ERROR_OPCODE;
+        pref &= ~PRE_66;
+
+        cflags = C_MODRM;
+        if (c == 0x8f) {
+            switch (map) {
+                case 8:                 /* every XOP8 opcode takes an imm8 */
+                    cflags |= C_IMM8;
+                    break;
+                case 9:                 /* no XOP9 opcode takes one */
+                    break;
+                case 10:                /* bextr and the lwp forms: imm32 */
+                    cflags |= C_IMM_P66;
+                    break;
+                default:
+                    hs->flags |= F_ERROR | F_ERROR_OPCODE;
+                    break;
+            }
+        } else switch (map) {
+            case 1:                     /* 0F map */
+                if (opcode == 0x70 || (opcode >= 0x71 && opcode <= 0x73) ||
+                    opcode == 0xc2 || (opcode >= 0xc4 && opcode <= 0xc6))
+                    cflags |= C_IMM8;
+                else if (c != 0x62 && opcode == 0x77)
+                    cflags = C_NONE;    /* vzeroupper and vzeroall: no ModR/M */
+                else if (c != 0x62 && (opcode == 0x84 || opcode == 0x85))
+                    cflags = C_REL32;   /* jkzd and jknzd: rel32, no ModR/M */
+                break;
+            case 2:                     /* 0F 38 map: never an immediate */
+                break;
+            case 3:                     /* 0F 3A map: always an imm8 */
+                cflags |= C_IMM8;
+                break;
+            case 5: case 6:             /* half-precision maps, EVEX only */
+                if (c != 0x62)
+                    hs->flags |= F_ERROR | F_ERROR_OPCODE;
+                else if (map == 5 && (opcode == 0x08 || opcode == 0x0a ||
+                                      opcode == 0x26 || opcode == 0x27 ||
+                                      opcode == 0x56 || opcode == 0x57 ||
+                                      opcode == 0x66 || opcode == 0x67 ||
+                                      opcode == 0xc2))
+                    cflags |= C_IMM8;   /* the 0F 3A forms of that map */
+                break;
+            default:
+                hs->flags |= F_ERROR | F_ERROR_OPCODE;
+                break;
+        }
+        ext = 1;
+        x = 0;
+        goto modrm;
+    }
+
+    /* REX2: D5, a payload byte, then the opcode. The payload names the
+     * opcode map in its top bit, so a 0F opcode is reached without the 0F
+     * byte, and carries the register extensions, with W where REX keeps it.
+     * Only legacy instructions are promoted this way, so the tables give the
+     * right shape once the map is known. */
+    if (c == 0xd5) {
+        NEED(2);
+        rex2 = *p++;
+        have_rex2 = 1;
+        c = *p++;
+        hs->flags |= F_PREFIX_REX2;
+        if (rex)                /* REX2 replaces a REX, it cannot follow one */
+            hs->flags |= F_ERROR | F_ERROR_OPCODE;
+        hs->rex_w = (rex2 & 8) >> 3;
+        hs->rex_r = (rex2 & 4) >> 2;
+        hs->rex_x = (rex2 & 2) >> 1;
+        hs->rex_b = rex2 & 1;
+        if (rex2 & 0x80) {
+            hs->opcode = 0xd5;
+            hs->opcode2 = c;
+            map0f = 1;
+            ht += DELTA_OPCODES;
+            goto opcode_ready;
+        }
+        /* Map 0 is the one-byte map, and REX2 has to be the last byte
+         * before the opcode: neither the 0F escape nor a further prefix
+         * can follow it. 8F is deliberately absent, and adding it would be
+         * wrong: it is POP here, not an XOP escape, and D5 00 8F C0 is a
+         * promoted pop. The other escapes are absent because their opcodes
+         * have no table entry, so they are rejected either way. */
+        if (c == 0x0f || (c & 0xf0) == 0x40 ||
+            c == 0x26 || c == 0x2e || c == 0x36 || c == 0x3e ||
+            c == 0x64 || c == 0x65 || c == 0x66 || c == 0x67 ||
+            c == 0xf0 || c == 0xf2 || c == 0xf3)
+            hs->flags |= F_ERROR | F_ERROR_OPCODE;
+        if (hs->rex_w && (c & 0xf8) == 0xb8)
+            op64++;             /* B8+r, map 0's mov r64, imm64 */
+    }
+
+    hs->opcode = c;
+    if (!have_rex2 && c == 0x0f) {
+        NEED(1);
+        hs->opcode2 = c = *p++;
+        map0f = 1;
+        if (c == 0x38 || c == 0x3a) {
+            /* Three-byte maps: the opcode follows and always has a ModR/M
+             * byte. Every 0F 3A opcode takes an imm8, no 0F 38 one does, and
+             * none of them is lockable. */
+            NEED(2);
+            opcode = *p++;
+            cflags = (c == 0x3a) ? (C_MODRM | C_IMM8) : C_MODRM;
+            if (pref & PRE_LOCK)
+                hs->flags |= F_ERROR | F_ERROR_LOCK;
+            ext = 1;
+            x = 0;
+            goto modrm;
+        }
+        ht += DELTA_OPCODES;
+    } else if (c >= 0xa0 && c <= 0xa3) {
+        /* moffs: the absolute address is as wide as the address size, so
+         * eight bytes unless 67 selects 32-bit addressing. */
+        if (!(pref & PRE_67))
+            op64++;
+        pref &= ~PRE_66;
+    }
+
+  opcode_ready:
+    opcode = c;
+    cflags = ht[ht[opcode / 4] + (opcode % 4)];
+
+    if (cflags == C_ERROR) {
+        /* The table carries no entry for the opcode. Some of these are real
+         * instructions whose shape is known, and flagging one denies the caller a
+         * length it could have used; the rest keep F_ERROR, because the opcode
+         * is not one this engine can claim to know. */
+        cflags = 0;
+        if (map0f && (opcode == 0x0b ||
+                            (opcode == 0x37 &&
+                             mand == PRE_NONE))) {
+            ;                           /* ud2 and getsec take no operand */
+        } else if (map0f && (opcode == 0xa6 || opcode == 0xa7 ||
+                                   opcode == 0xb9 || opcode == 0xff)) {
+            cflags = C_MODRM;           /* PadLock, ud1 and ud0 */
+        } else if (!map0f && (opcode == 0x9e || opcode == 0x9f)) {
+            ;                           /* sahf and lahf, back since 2006 */
+        } else {
+            hs->flags |= F_ERROR | F_ERROR_OPCODE;
+            if (map0f && (opcode & -3) == 0x24)
+                cflags = C_MODRM;       /* the test registers: shape only */
+        }
+    }
+
+    x = 0;
+    if (cflags & C_GROUP) {
+        uint16_t t;
+        t = *(uint16_t *)(ht + (cflags & 0x7f));
+        cflags = (uint8_t)t;
+        x = (uint8_t)(t >> 8);
+    }
+
+    if (map0f) {
+        ht = hde64_table + DELTA_PREFIXES;
+        /* movntsd and movntss are F2 0F 2B and F3 0F 2B. The row 0F 2B
+         * reads rejects both, and it is shared with a neighbour that has
+         * no such form, so the exception lives here rather than in the
+         * table. */
+        if ((ht[ht[opcode / 4] + (opcode % 4)] & mand) &&
+            !(opcode == 0x2b && (mand & (PRE_F2 | PRE_F3))))
+            hs->flags |= F_ERROR | F_ERROR_OPCODE;
+        /* vmread, vmwrite and popcnt take a ModR/M byte that the table cannot
+         * give them: their entries share a row with opcodes that take none. */
+        if (opcode == 0x78 || opcode == 0x79 || opcode == 0xb8)
+            cflags |= C_MODRM;
+    }
+
+  modrm:
+    if (cflags & C_MODRM) {
+        hs->flags |= F_MODRM;
+        NEED(1);
+        hs->modrm = c = *p++;
+        hs->modrm_mod = m_mod = c >> 6;
+        hs->modrm_rm = m_rm = c & 7;
+        hs->modrm_reg = m_reg = (c & 0x3f) >> 3;
+
+        if (x && ((x << m_reg) & 0x80))
+            hs->flags |= F_ERROR | F_ERROR_OPCODE;
+
+        if (ext)
+            goto no_error_operand;      /* no legacy operand rule applies */
+
+        if (!map0f && opcode >= 0xd9 && opcode <= 0xdf) {
+            uint8_t t = opcode - 0xd9;
+            if (m_mod == 3) {
+                ht = hde64_table + DELTA_FPU_MODRM + t*8;
+                t = ht[m_reg] << m_rm;
+            } else {
+                ht = hde64_table + DELTA_FPU_REG;
+                t = ht[t] << m_reg;
+            }
+            if (t & 0x80)
+                hs->flags |= F_ERROR | F_ERROR_OPCODE;
+        }
+
+        if (pref & PRE_LOCK) {
+            if (m_mod == 3) {
+                hs->flags |= F_ERROR | F_ERROR_LOCK;
+            } else {
+                uint8_t *table_end, op = opcode;
+                if (map0f) {
+                    ht = hde64_table + DELTA_OP2_LOCK_OK;
+                    table_end = ht + DELTA_OP_ONLY_MEM - DELTA_OP2_LOCK_OK;
+                } else {
+                    ht = hde64_table + DELTA_OP_LOCK_OK;
+                    table_end = ht + DELTA_OP2_LOCK_OK - DELTA_OP_LOCK_OK;
+                    op &= -2;
+                }
+                for (; ht != table_end; ht++)
+                    if (*ht++ == op) {
+                        if (!((*ht << m_reg) & 0x80))
+                            goto no_lock_error;
+                        else
+                            break;
+                    }
+                hs->flags |= F_ERROR | F_ERROR_LOCK;
+              no_lock_error:
+                ;
+            }
+        }
+
+        if (map0f) {
+            switch (opcode) {
+                case 0x20: case 0x22:
+                    m_mod = 3;
+                    if (m_reg > 4 || m_reg == 1)
+                        goto error_operand;
+                    else
+                        goto no_error_operand;
+                case 0x21: case 0x23:
+                    m_mod = 3;
+                    /* dr4 and dr5 alias dr6 and dr7 unless CR4.DE is set, so
+                     * they decode rather than fault. */
+                    goto no_error_operand;
+            }
+        } else {
+            switch (opcode) {
+                case 0x8c:
+                    if (m_reg > 5)
+                        goto error_operand;
+                    else
+                        goto no_error_operand;
+                case 0x8e:
+                    if (m_reg == 1 || m_reg > 5)
+                        goto error_operand;
+                    else
+                        goto no_error_operand;
+            }
+        }
+
+        if (m_mod == 3) {
+            uint8_t *table_end;
+            if (map0f) {
+                ht = hde64_table + DELTA_OP2_ONLY_MEM;
+                table_end = ht + sizeof(hde64_table) - DELTA_OP2_ONLY_MEM;
+            } else {
+                ht = hde64_table + DELTA_OP_ONLY_MEM;
+                table_end = ht + DELTA_OP2_ONLY_MEM - DELTA_OP_ONLY_MEM;
+            }
+            for (; ht != table_end; ht += 2)
+                if (*ht++ == opcode) {
+                    if ((*ht++ & mand) && !((*ht << m_reg) & 0x80))
+                        goto error_operand;
+                    else
+                        break;
+                }
+            goto no_error_operand;
+        } else if (map0f) {
+            switch (opcode) {
+                case 0x50: case 0xd7: case 0xf7:
+                    if (mand & (PRE_NONE | PRE_66))
+                        goto error_operand;
+                    break;
+                case 0xd6:
+                    if (mand & (PRE_F2 | PRE_F3))
+                        goto error_operand;
+                    break;
+                case 0xc5:
+                    goto error_operand;
+            }
+            goto no_error_operand;
+        } else
+            goto no_error_operand;
+
+      error_operand:
+        hs->flags |= F_ERROR | F_ERROR_OPERAND;
+      no_error_operand:
+
+        /* Group 3: F6 /0 and /1 take an imm8, F7 /0 and /1 an imm32 or imm16.
+         * The rule belongs to the one-byte map; 0F F6 and 0F F7 are psadbw
+         * and maskmovq, which take neither. */
+        if (!ext && !map0f && m_reg <= 1) {
+            if (opcode == 0xf6)
+                cflags |= C_IMM8;
+            else if (opcode == 0xf7)
+                cflags |= C_IMM_P66;
+        }
+        /* C7 /7 is xbegin, whose immediate is a displacement. */
+        if (!ext && !map0f && opcode == 0xc7 && m_reg == 7)
+            hs->flags |= F_RELATIVE;
+        /* extrq and insertq take two imm8 operands where vmread takes none. */
+        if (!ext && map0f && opcode == 0x78 && (mand & (PRE_66 | PRE_F2)))
+            cflags |= C_IMM16;
+
+        switch (m_mod) {
+            case 0:
+                if (m_rm == 5)
+                    disp_size = 4;
+                break;
+            case 1:
+                disp_size = 1;
+                break;
+            case 2:
+                disp_size = 4;
+                break;
+        }
+
+        if (m_mod != 3 && m_rm == 4) {
+            hs->flags |= F_SIB;
+            NEED(1);
+            hs->sib = c = *p++;
+            hs->sib_scale = c >> 6;
+            hs->sib_index = (c & 0x3f) >> 3;
+            if ((hs->sib_base = c & 7) == 5 && !(m_mod & 1))
+                disp_size = 4;
+        }
+
+        if (disp_size) {
+            NEED(disp_size);
+            if (disp_size == 1) {
+                hs->flags |= F_DISP8;
+                hs->disp.disp8 = *p;
+            } else {
+                hs->flags |= F_DISP32;
+                hs->disp.disp32 = *(uint32_t *)p;
+            }
+            p += disp_size;
+        }
+    } else if (pref & PRE_LOCK)
+        hs->flags |= F_ERROR | F_ERROR_LOCK;
+
+    /* An operand-size dependent immediate is 32 bits wide, 16 under a 66
+     * prefix, and 32 again when a REX.W overrides that prefix. */
+    if (cflags & C_IMM_P66) {
+        if (cflags & C_REL32) {
+            if ((pref & PRE_66) && !hs->rex_w) {
+                NEED(2);
+                hs->flags |= F_IMM16 | F_RELATIVE;
+                hs->imm.imm16 = *(uint16_t *)p;
+                p += 2;
+                goto disasm_done;
+            }
+            goto rel32_ok;
+        }
+        if (op64) {
+            NEED(8);
+            hs->flags |= F_IMM64;
+            hs->imm.imm64 = *(uint64_t *)p;
+            p += 8;
+        } else if (!(pref & PRE_66) || hs->rex_w) {
+            NEED(4);
+            hs->flags |= F_IMM32;
+            hs->imm.imm32 = *(uint32_t *)p;
+            p += 4;
+        } else
+            goto imm16_ok;
+    }
+
+
+    if (cflags & C_IMM16) {
+      imm16_ok:
+        NEED(2);
+        hs->flags |= F_IMM16;
+        hs->imm.imm16 = *(uint16_t *)p;
+        p += 2;
+    }
+    if (cflags & C_IMM8) {
+        NEED(1);
+        hs->flags |= F_IMM8;
+        if (hs->flags & F_IMM16)
+            hs->disp.disp8 = *p++;      /* enter: the union holds the imm16 */
+        else
+            hs->imm.imm8 = *p++;
+    }
+
+    if (cflags & C_REL32) {
+      rel32_ok:
+        NEED(4);
+        hs->flags |= F_IMM32 | F_RELATIVE;
+        hs->imm.imm32 = *(uint32_t *)p;
+        p += 4;
+    } else if (cflags & C_REL8) {
+        NEED(1);
+        hs->flags |= F_IMM8 | F_RELATIVE;
+        hs->imm.imm8 = *p++;
+    }
+
+  disasm_done:
+
+    hs->len = (uint8_t)(p - (uint8_t *)code);
+    return (unsigned int)hs->len;
+
+  error_length:
+
+    hs->flags |= F_ERROR | F_ERROR_LENGTH;
+    hs->len = 15;
+    return 15;
+}
+
+#undef NEED
+
+#endif // defined(_M_X64) || defined(__x86_64__)

package/native/hde/hde64.h

@@ -0,0 +1,113 @@
+/*
+ * Hacker Disassembler Engine 64
+ * Copyright (c) 2008-2009, Vyacheslav Patkov.
+ * All rights reserved.
+ *
+ * hde64.h: C/C++ header file
+ *
+ */
+
+#ifndef _HDE64_H_
+#define _HDE64_H_
+
+/* stdint.h - C99 standard header
+ * http://en.wikipedia.org/wiki/stdint.h
+ *
+ * if your compiler doesn't contain "stdint.h" header (for
+ * example, Microsoft Visual C++), you can download file:
+ *   http://www.azillionmonkeys.com/qed/pstdint.h
+ * and change next line to:
+ *   #include "pstdint.h"
+ */
+#include "pstdint.h"
+
+#define F_MODRM         0x00000001
+#define F_SIB           0x00000002
+#define F_IMM8          0x00000004
+#define F_IMM16         0x00000008
+#define F_IMM32         0x00000010
+#define F_IMM64         0x00000020
+#define F_DISP8         0x00000040
+#define F_DISP16        0x00000080
+#define F_DISP32        0x00000100
+#define F_RELATIVE      0x00000200
+#define F_ERROR         0x00001000
+#define F_ERROR_OPCODE  0x00002000
+#define F_ERROR_LENGTH  0x00004000
+#define F_ERROR_LOCK    0x00008000
+#define F_ERROR_OPERAND 0x00010000
+#define F_PREFIX_REPNZ  0x01000000
+#define F_PREFIX_REPX   0x02000000
+#define F_PREFIX_REP    0x03000000
+#define F_PREFIX_66     0x04000000
+#define F_PREFIX_67     0x08000000
+#define F_PREFIX_LOCK   0x10000000
+#define F_PREFIX_SEG    0x20000000
+#define F_PREFIX_REX    0x40000000
+#define F_PREFIX_REX2   0x80000000
+#define F_PREFIX_ANY    0xff000000
+
+#define PREFIX_SEGMENT_CS   0x2e
+#define PREFIX_SEGMENT_SS   0x36
+#define PREFIX_SEGMENT_DS   0x3e
+#define PREFIX_SEGMENT_ES   0x26
+#define PREFIX_SEGMENT_FS   0x64
+#define PREFIX_SEGMENT_GS   0x65
+#define PREFIX_LOCK         0xf0
+#define PREFIX_REPNZ        0xf2
+#define PREFIX_REPX         0xf3
+#define PREFIX_OPERAND_SIZE 0x66
+#define PREFIX_ADDRESS_SIZE 0x67
+
+#pragma pack(push,1)
+
+typedef struct {
+    uint8_t len;
+    uint8_t p_rep;
+    uint8_t p_lock;
+    uint8_t p_seg;
+    uint8_t p_66;
+    uint8_t p_67;
+    uint8_t rex;
+    uint8_t rex_w;
+    uint8_t rex_r;
+    uint8_t rex_x;
+    uint8_t rex_b;
+    uint8_t opcode;
+    uint8_t opcode2;
+    uint8_t modrm;
+    uint8_t modrm_mod;
+    uint8_t modrm_reg;
+    uint8_t modrm_rm;
+    uint8_t sib;
+    uint8_t sib_scale;
+    uint8_t sib_index;
+    uint8_t sib_base;
+    union {
+        uint8_t imm8;
+        uint16_t imm16;
+        uint32_t imm32;
+        uint64_t imm64;
+    } imm;
+    union {
+        uint8_t disp8;
+        uint16_t disp16;
+        uint32_t disp32;
+    } disp;
+    uint32_t flags;
+} hde64s;
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* __cdecl */
+unsigned int hde64_disasm(const void *code, hde64s *hs);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _HDE64_H_ */

package/native/hde/pstdint.h

@@ -0,0 +1,39 @@
+/*
+ *  MinHook - The Minimalistic API Hooking Library for x64/x86
+ *  Copyright (C) 2009-2017 Tsuda Kageyu. All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <windows.h>
+
+// Integer types for HDE.
+typedef INT8   int8_t;
+typedef INT16  int16_t;
+typedef INT32  int32_t;
+typedef INT64  int64_t;
+typedef UINT8  uint8_t;
+typedef UINT16 uint16_t;
+typedef UINT32 uint32_t;
+typedef UINT64 uint64_t;