inital commit. currently all winapi

hook.c

+/*
+\todo:
+What if there's a loop in the function which loops back to an overwritten instruction?
+start:
+	jmp hook_function
+	bla
+	jXX start+3
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <Windows.h>
+#include "udis86.h"
+#include "list.h"
+#include "hook.h"
+
+#define MINIMUM_REQUIRED_FUNCTION_LENGTH_SHORT_HOOK 5
+#define MINIMUM_REQUIRED_FUNCTION_LENGTH_LONG_HOOK 16
+#define MAXIMUM_DISTANCE_FOR_SHORT_HOOK 0xFFFFFFFF
+#define PAGE_BOUNDARY 0x1000
+
+/**
+	\brief Estimates the function size by checking opcodes until 
+		* an instruction that signifies the end of the function or
+		* MINIMUM_REQUIRED_FUNCTION_LENGTH_LONG_HOOK bytes were found
+	\return 0 on error
+*/
+static size_t estimate_function_length(void* function);
+
+/**
+	\brief Either builds the trampoline
+	\param functionSize How much of the function shall be copied
+	\param trampolineSize out parameter
+*/
+static void* build_trampoline(void* function, size_t functionSize, size_t* trampolineSize);
+
+/**
+\brief jmp +X == +X + sizeof(jump type) + eip
+*/
+static size_t get_jump_offset(ud_t* ud, size_t offsetOfInstr);
+
+/**
+\todo add loop & jecx (and possibly more) - though both are probably only used to jump back
+and currently is_jump is only called to from functions that don't care about that
+*/
+static bool is_jump(enum ud_mneomic_code op);
+
+/**
+\brief Writes
+jmp [$+0] // $+0 == addr
+addr: xxx
+*/
+static size_t write_x64_jump(unsigned char* where, void* toWhere);
+
+static bool is_end_of_function(enum ud_mneomic_code opc, ud_t* ud, size_t furthestJump, size_t instrOffset);
+static bool loops_into_overwritten_code(void* function);
+static size_t write_jcc_jump(const uint8_t* instruction, void* whereToWrite, void* originalAddr);
+static void fix_jcc_jumps(struct ListHead* instructions, struct ListHead* jccs);
+static int32_t get_rip_delta(ud_t* ud);
+static size_t write_instr_with_rip_delta(ud_t* ud, uint64_t absoluteAddr, const uint8_t* opcBuf, unsigned char* where);
+
+int hook(void* function, size_t functionLength, void* replacement, void** trampoline)
+{
+	ptrdiff_t d = 0; // function minus replacement
+	size_t needed = 0,
+		trampolineSizeNeeded = 0;
+
+	assert(function);
+	assert(replacement);
+	assert(trampoline);
+
+	if(!functionLength)
+		functionLength = estimate_function_length(function);
+
+	/* is it actually possible to hook, space wise? */
+	d = (ptrdiff_t)function - (ptrdiff_t)replacement;
+	needed = d > MAXIMUM_DISTANCE_FOR_SHORT_HOOK ? 
+		MINIMUM_REQUIRED_FUNCTION_LENGTH_LONG_HOOK : MINIMUM_REQUIRED_FUNCTION_LENGTH_SHORT_HOOK;
+	if(functionLength < needed)
+		return NOT_ENOUGH_SPACE;
+
+	if(loops_into_overwritten_code(function))
+		return LOOPS_INTO_OVERWRITTEN_CODE;
+
+	//! fixme: Remove in real code
+	needed = MINIMUM_REQUIRED_FUNCTION_LENGTH_LONG_HOOK; 
+
+	printf("---\nNow build the trampoline\n");
+	if((*trampoline = build_trampoline(function, needed, &trampolineSizeNeeded)) < 0)
+		return (int)*trampoline;
+	printf("Needed for trampoline %p: %d (Found %d)\n", *trampoline, trampolineSizeNeeded, functionLength);
+
+	return SUCCESS;
+}
+
+static void* build_trampoline(void* function, size_t functionSize, size_t* trampolineSize)
+{
+	ud_t ud;
+	void* trampoline;
+
+	assert(trampolineSize);
+
+	ud_init(&ud);
+	ud_set_input_buffer(&ud, function, (size_t)function | (PAGE_BOUNDARY - 1)); // Can't read further than page boundary - there be dragons
+	ud_set_pc(&ud, (uint64_t)function);
+	ud_set_mode(&ud, 64);
+	ud_set_syntax(&ud, UD_SYN_INTEL);
+
+	*trampolineSize = 0;
+
+	if(!(trampoline = VirtualAlloc(NULL, PAGE_BOUNDARY, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE)))
+		return (void*)CANT_ALLOC;
+	printf("trampoline @ %p\n", trampoline);
+
+	size_t sz = 0;
+	for(; sz <= functionSize;)
+	{
+		size_t instrLen = 0,
+			offsetOfInstr = sz;
+		bool neededFixup = false;
+		uint8_t* addrForInstr = (uint8_t*)trampoline + *trampolineSize;
+		const uint8_t* buf = NULL;
+
+		assert(*trampolineSize < PAGE_BOUNDARY);
+
+		if(!(instrLen = ud_disassemble(&ud)) || ud.error)
+			return 0;
+		buf = ud_insn_ptr(&ud);
+
+		sz += instrLen;
+		printf("%p %s", ud_insn_off(&ud), ud_insn_asm(&ud));
+
+		
+		// Check for XXX [rip + ?]
+		const struct ud_operand* op = NULL;
+		for(int i = 0; op = ud_insn_opr(&ud, i); i++)
+		{
+			if((op->type & UD_OP_REG) == UD_OP_REG)
+			{
+				if(op->base != UD_R_RIP)
+					continue;
+				neededFixup = true;
+				
+				
+				int32_t ripDelta = get_rip_delta(&ud);
+				void* absoluteAddr = ripDelta + ud_insn_off(&ud) + instrLen;
+				printf("RIP + %x == %p\n", ripDelta, absoluteAddr);
+				
+				*trampolineSize += write_instr_with_rip_delta(&ud, absoluteAddr, buf, addrForInstr);
+				
+				break;
+			}
+		}
+
+		// Check for jmp/jcc that would jump into the void after the trampoline
+		size_t originalOff;
+		if((originalOff = get_jump_offset(&ud, offsetOfInstr)) >= functionSize)
+		{
+			neededFixup = true;
+
+			void* absoluteAddr = originalOff + (uint8_t*)function;
+
+#if 0
+			printf("\nWould jump behind trampoline (to %p -- offs: %d) into the void\n", absoluteAddr, originalOff);
+			printf("Instr in Trampoline @ %d jumps %d forward\n", *trampolineSize, originalOff);
+			printf("%p - %p = %p\n", trampoline, ((ptrdiff_t)function + originalOff), (ptrdiff_t)trampoline - ((ptrdiff_t)function + originalOff));
+#endif
+
+			// Normal jump
+			if(buf[0] == 0xEB || buf[0] == 0xE9)
+			{
+				*trampolineSize += write_x64_jump(addrForInstr, absoluteAddr);
+			}
+			// jcc todo: jecxz, loop(?)
+			else
+			{
+				*trampolineSize += write_jcc_jump(buf, addrForInstr, absoluteAddr);
+			}
+		}
+
+		// todo: Fix relative calls
+		
+
+		printf("\n");
+
+		// If it was a normal instruction, just copy it
+		if(!neededFixup)
+		{
+			memcpy(addrForInstr, buf, instrLen);
+
+			*trampolineSize += instrLen;
+		}
+	}
+
+
+
+	// Build jmp back to original function
+	*trampolineSize += write_x64_jump((uint8_t*)trampoline + *trampolineSize, (uint8_t*)function + sz);
+
+
+	return trampoline;
+}
+
+
+static size_t write_instr_with_rip_delta(ud_t* ud, uint64_t value, const uint8_t* opcBuf, unsigned char* where)
+{
+	// 5, d, 15, 1d, 25
+	printf(value);
+	
+
+	/*XXX yyy, [addr]
+	jmp behind
+	addr:
+		value
+	behind:
+	*/
+
+	return 0;
+}
+
+static int32_t get_rip_delta(ud_t* ud)
+{
+	const struct ud_operand* op = NULL;
+	int32_t ret = 0;
+
+	for(int i = 0; op = ud_insn_opr(ud, i); i++)
+	{
+		// Only the RIP offset is interesting
+		if((op->type & UD_OP_REG) != UD_OP_REG || op->base != UD_R_RIP)
+			continue;
+
+		return op->lval.sdword;
+		
+	}
+
+	return ret;
+}
+
+static size_t write_jcc_jump(const uint8_t* instruction, void* whereToWrite, void* originalAddr)
+{
+	/*
+	jX $+?
+
+	is transformed into:
+
+	jnX behind
+	jmp [originalAddr]
+	originalAddr:
+		?
+	behind:
+	*/
+
+	// Stolen from https://github.com/TsudaKageyu/minhook/blob/master/src/trampoline.c
+	uint8_t cond = ((instruction[0] != 0x0F ? instruction[0] : instruction[1]) & 0x0F);
+	uint8_t newConditionOpc = 0x71 ^ cond; // Invert the condition in x64 mode to simplify the conditional jump logic.
+
+	// jnx behind
+	char jccTemplate[] = {newConditionOpc, 0x0F};
+	memcpy((unsigned char*)whereToWrite, jccTemplate, sizeof(jccTemplate));
+	size_t written = sizeof(jccTemplate);
+
+	// jmp [originalAddr]
+	written += write_x64_jump((unsigned char*)whereToWrite + written, originalAddr);
+
+	return written;
+}
+
+static size_t get_jump_offset(ud_t* ud, size_t offsetOfInstr)
+{
+	const struct ud_operand* op = NULL;
+	for(int i = 0; op = ud_insn_opr(ud, i); i++)
+	{
+		if(op->type == UD_OP_JIMM)
+		{
+			return op->lval.sdword + offsetOfInstr + ud_insn_len(ud);
+		}
+		// all other types are weird jumps, like jumps to a register or to []
+	}
+
+	return 0;
+}
+
+static bool is_jump(enum ud_mneomic_code op)
+{
+	return op >= UD_Ijo && op <= UD_Ijmp;
+}
+
+static bool is_end_of_function(enum ud_mneomic_code opc, ud_t* ud, size_t furthestJump, size_t instrOffset)
+{
+	if(opc == UD_Iret && furthestJump <= instrOffset)
+		return true;
+	else if(opc == UD_Ijmp)
+	{
+		const struct ud_operand* op = ud_insn_opr(ud, 0);
+		if(op->type == UD_OP_MEM || op->type == UD_OP_REG)
+			return true;
+	}
+	// todo: 0xCC ?
+
+	return false;
+}
+
+static size_t estimate_function_length(void* function)
+{
+	size_t furthestJump = 0; //! Functions can have multiple return points. The library assumes that if a RET is hit and a jmp/jcc went over it, this RET isn't the last
+	unsigned char* p = function;
+	size_t funcLen = 0;
+	ud_t ud;
+
+	ud_init(&ud);
+	ud_set_input_buffer(&ud, function, (size_t)function | (PAGE_BOUNDARY - 1)); // Can't read further than page boundary - there be dragons
+	ud_set_pc(&ud, (uint64_t)function);
+	ud_set_mode(&ud, 64);
+	ud_set_syntax(&ud, UD_SYN_INTEL);
+
+	while(funcLen < MINIMUM_REQUIRED_FUNCTION_LENGTH_LONG_HOOK && !ud_input_end(&ud))
+	{
+		size_t instrLen = 0,
+			offsetOfInstr = funcLen;
+		if(!(instrLen = ud_disassemble(&ud)) || ud.error)
+			return 0;
+
+		p += instrLen;
+		funcLen += instrLen;
+
+		printf("%p %s", ud_insn_off(&ud), ud_insn_asm(&ud));
+
+		enum ud_mneomic_code op = ud_insn_mnemonic(&ud);
+		if(is_jump(op))
+		{
+			size_t off = get_jump_offset(&ud, offsetOfInstr);
+			if(off > furthestJump)
+				furthestJump = off;
+		}
+
+		if(is_end_of_function(op, &ud, furthestJump, offsetOfInstr))
+		{
+			printf("end of function\n");
+			break;
+		}
+
+		printf("\n");
+	}
+
+	return funcLen;
+}
+
+static size_t write_x64_jump(unsigned char* where, void* toWhere)
+{
+	const char jmpMemTemplate[] = {0x48, 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00};
+
+	memcpy(where, jmpMemTemplate, sizeof(jmpMemTemplate));
+	where += sizeof(jmpMemTemplate);
+
+	memcpy(where, &toWhere, sizeof(toWhere));
+
+	return sizeof(jmpMemTemplate)+sizeof(toWhere);
+}
+
+//! fixme:
+static bool loops_into_overwritten_code(void* function)
+{
+	return false;
+}

hook.h

+#ifndef HOOK_H
+#define HOOK_H
+
+/**
+	x64 Hooking Library.
+*/
+
+typedef enum HOOK_STATUS
+{
+	SUCCESS = 0,
+	NOT_ENOUGH_SPACE = -1,
+	CANT_ALLOC = -2,
+	LOOPS_INTO_OVERWRITTEN_CODE = -3
+};
+
+/**
+	\brief 
+	\param functionLength Length of the function you want to hook. If the length isn't known, pass 0 and the library will try to figure it out
+*/
+int hook(void* function, size_t functionLength, void* replacement, void* trampoline);
+
+#endif

libudis86/Makefile.am

+#
+# -- udis86/libudis86
+#
+
+PYTHON  = @PYTHON@
+OPTABLE = @top_srcdir@/docs/x86/optable.xml
+
+MAINTAINERCLEANFILES = Makefile.in
+
+lib_LTLIBRARIES	= libudis86.la
+
+libudis86_la_SOURCES =	\
+    itab.c \
+    decode.c \
+    syn.c \
+    syn-intel.c \
+    syn-att.c \
+    udis86.c \
+	udint.h \
+    syn.h \
+    decode.h
+
+include_ladir = ${includedir}/libudis86
+include_la_HEADERS = \
+    types.h \
+    extern.h \
+    itab.h
+
+
+BUILT_SOURCES = \
+    itab.c \
+    itab.h
+
+#
+# DLLs may not contain undefined symbol references.  
+# We have the linker check this explicitly.
+#
+if TARGET_WINDOWS
+libudis86_la_LDFLAGS = -no-undefined -version-info 0:0:0
+endif
+
+itab.c itab.h: $(OPTABLE) \
+			   $(top_srcdir)/scripts/ud_itab.py \
+               $(top_srcdir)/scripts/ud_opcode.py \
+               $(top_srcdir)/scripts/ud_optable.py
+	$(PYTHON) $(top_srcdir)/scripts/ud_itab.py $(OPTABLE) $(srcdir)
+
+
+clean-local:
+	rm -rf $(BUILT_SOURCES)
+
+maintainer-clean-local:

libudis86/Makefile.in

+# Makefile.in generated by automake 1.13.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2012 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+#
+# -- udis86/libudis86
+#
+
+
+VPATH = @srcdir@
+am__make_dryrun = \
+  { \
+    am__dry=no; \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
+          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+      *) \
+        for am__flg in $$MAKEFLAGS; do \
+          case $$am__flg in \
+            *=*|--*) ;; \
+            *n*) am__dry=yes; break;; \
+          esac; \
+        done;; \
+    esac; \
+    test $$am__dry = yes; \
+  }
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = libudis86
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+	$(top_srcdir)/build/depcomp $(include_la_HEADERS)
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/build/m4/libtool.m4 \
+	$(top_srcdir)/build/m4/ltoptions.m4 \
+	$(top_srcdir)/build/m4/ltsugar.m4 \
+	$(top_srcdir)/build/m4/ltversion.m4 \
+	$(top_srcdir)/build/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/ax_compare_version.m4 \
+	$(top_srcdir)/m4/ax_prog_sphinx_version.m4 \
+	$(top_srcdir)/m4/ax_prog_yasm_version.m4 \
+	$(top_srcdir)/m4/ax_with_prog.m4 \
+	$(top_srcdir)/m4/ax_with_python.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(include_ladir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+libudis86_la_LIBADD =
+am_libudis86_la_OBJECTS = itab.lo decode.lo syn.lo syn-intel.lo \
+	syn-att.lo udis86.lo
+libudis86_la_OBJECTS = $(am_libudis86_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
+libudis86_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(libudis86_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN     " $@;
+am__v_GEN_1 = 
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 = 
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/build/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 = 
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 = 
+SOURCES = $(libudis86_la_SOURCES)
+DIST_SOURCES = $(libudis86_la_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+HEADERS = $(include_la_HEADERS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SPHINX_BUILD = @SPHINX_BUILD@
+SPHINX_VERSION = @SPHINX_VERSION@
+STRIP = @STRIP@
+VERSION = @VERSION@
+YASM = @YASM@
+YASM_VERSION = @YASM_VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+OPTABLE = @top_srcdir@/docs/x86/optable.xml
+MAINTAINERCLEANFILES = Makefile.in
+lib_LTLIBRARIES = libudis86.la
+libudis86_la_SOURCES = \
+    itab.c \
+    decode.c \
+    syn.c \
+    syn-intel.c \
+    syn-att.c \
+    udis86.c \
+	udint.h \
+    syn.h \
+    decode.h
+
+include_ladir = ${includedir}/libudis86
+include_la_HEADERS = \
+    types.h \
+    extern.h \
+    itab.h
+
+BUILT_SOURCES = \
+    itab.c \
+    itab.h
+
+
+#
+# DLLs may not contain undefined symbol references.  
+# We have the linker check this explicitly.
+#
+@TARGET_WINDOWS_TRUE@libudis86_la_LDFLAGS = -no-undefined -version-info 0:0:0
+all: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign libudis86/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign libudis86/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+	}
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; \
+	locs=`for p in $$list; do echo $$p; done | \
+	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+	      sort -u`; \
+	test -z "$$locs" || { \
+	  echo rm -f $${locs}; \
+	  rm -f $${locs}; \
+	}
+libudis86.la: $(libudis86_la_OBJECTS) $(libudis86_la_DEPENDENCIES) $(EXTRA_libudis86_la_DEPENDENCIES) 
+	$(AM_V_CCLD)$(libudis86_la_LINK) -rpath $(libdir) $(libudis86_la_OBJECTS) $(libudis86_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/itab.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/syn-att.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/syn-intel.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/syn.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/udis86.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-include_laHEADERS: $(include_la_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(include_la_HEADERS)'; test -n "$(include_ladir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(include_ladir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(include_ladir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(include_ladir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(include_ladir)" || exit $$?; \
+	done
+
+uninstall-include_laHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(include_la_HEADERS)'; test -n "$(include_ladir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(include_ladir)'; $(am__uninstall_files_from_dir)
+
+ID: $(am__tagged_files)
+	$(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	set x; \
+	here=`pwd`; \
+	$(am__define_uniq_tagged_files); \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+	$(am__define_uniq_tagged_files); \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+	list='$(am__tagged_files)'; \
+	case "$(srcdir)" in \
+	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+	  *) sdir=$(subdir)/$(srcdir) ;; \
+	esac; \
+	for i in $$list; do \
+	  if test -f "$$i"; then \
+	    echo "$(subdir)/$$i"; \
+	  else \
+	    echo "$$sdir/$$i"; \
+	  fi; \
+	done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) check-am
+all-am: Makefile $(LTLIBRARIES) $(HEADERS)
+installdirs:
+	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(include_ladir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
+	-test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool clean-local \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-include_laHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic \
+	maintainer-clean-local
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-include_laHEADERS uninstall-libLTLIBRARIES
+
+.MAKE: all check install install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+	clean-libLTLIBRARIES clean-libtool clean-local cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
+	distclean-libtool distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am \
+	install-include_laHEADERS install-info install-info-am \
+	install-libLTLIBRARIES install-man install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic maintainer-clean-local mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \
+	uninstall-include_laHEADERS uninstall-libLTLIBRARIES
+
+
+itab.c itab.h: $(OPTABLE) \
+			   $(top_srcdir)/scripts/ud_itab.py \
+               $(top_srcdir)/scripts/ud_opcode.py \
+               $(top_srcdir)/scripts/ud_optable.py
+	$(PYTHON) $(top_srcdir)/scripts/ud_itab.py $(OPTABLE) $(srcdir)
+
+clean-local:
+	rm -rf $(BUILT_SOURCES)
+
+maintainer-clean-local:
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

libudis86/decode.h

+/* udis86 - libudis86/decode.h
+ *
+ * Copyright (c) 2002-2009 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef UD_DECODE_H
+#define UD_DECODE_H
+
+#include "types.h"
+#include "itab.h"
+
+#define MAX_INSN_LENGTH 15
+
+/* itab prefix bits */
+#define P_none          ( 0 )
+#define P_cast          ( 1 << 0 )
+#define P_CAST(n)       ( ( n >> 0 ) & 1 )
+#define P_rexb          ( 1 << 1 )
+#define P_REXB(n)       ( ( n >> 1 ) & 1 )
+#define P_inv64         ( 1 << 4 )
+#define P_INV64(n)      ( ( n >> 4 ) & 1 )
+#define P_rexw          ( 1 << 5 )
+#define P_REXW(n)       ( ( n >> 5 ) & 1 )
+#define P_def64         ( 1 << 7 )
+#define P_DEF64(n)      ( ( n >> 7 ) & 1 )
+#define P_rexr          ( 1 << 8 )
+#define P_REXR(n)       ( ( n >> 8 ) & 1 )
+#define P_oso           ( 1 << 9 )
+#define P_OSO(n)        ( ( n >> 9 ) & 1 )
+#define P_aso           ( 1 << 10 )
+#define P_ASO(n)        ( ( n >> 10 ) & 1 )
+#define P_rexx          ( 1 << 11 )
+#define P_REXX(n)       ( ( n >> 11 ) & 1 )
+#define P_ImpAddr       ( 1 << 12 )
+#define P_IMPADDR(n)    ( ( n >> 12 ) & 1 )
+#define P_seg           ( 1 << 13 )
+#define P_SEG(n)        ( ( n >> 13 ) & 1 )
+#define P_str           ( 1 << 14 )
+#define P_STR(n)        ( ( n >> 14 ) & 1 )
+#define P_strz          ( 1 << 15 )
+#define P_STR_ZF(n)     ( ( n >> 15 ) & 1 )
+
+/* operand type constants -- order is important! */
+
+enum ud_operand_code {
+    OP_NONE,
+
+    OP_A,      OP_E,      OP_M,       OP_G,       
+    OP_I,      OP_F,
+
+    OP_R0,     OP_R1,     OP_R2,      OP_R3,
+    OP_R4,     OP_R5,     OP_R6,      OP_R7,
+
+    OP_AL,     OP_CL,     OP_DL,
+    OP_AX,     OP_CX,     OP_DX,
+    OP_eAX,    OP_eCX,    OP_eDX,
+    OP_rAX,    OP_rCX,    OP_rDX,
+
+    OP_ES,     OP_CS,     OP_SS,      OP_DS,  
+    OP_FS,     OP_GS,
+
+    OP_ST0,    OP_ST1,    OP_ST2,     OP_ST3,
+    OP_ST4,    OP_ST5,    OP_ST6,     OP_ST7,
+
+    OP_J,      OP_S,      OP_O,          
+    OP_I1,     OP_I3,     OP_sI,
+
+    OP_V,      OP_W,      OP_Q,       OP_P, 
+    OP_U,      OP_N,      OP_MU,
+
+    OP_R,      OP_C,      OP_D,       
+
+    OP_MR
+} UD_ATTR_PACKED;
+
+
+/* operand size constants */
+
+enum ud_operand_size {
+    SZ_NA  = 0,
+    SZ_Z   = 1,
+    SZ_V   = 2,
+    SZ_RDQ = 7,
+
+    /* the following values are used as is,
+     * and thus hard-coded. changing them 
+     * will break internals 
+     */
+    SZ_B   = 8,
+    SZ_W   = 16,
+    SZ_D   = 32,
+    SZ_Q   = 64,
+    SZ_T   = 80,
+    SZ_O   = 128,
+
+    SZ_Y   = 17,
+
+    /*
+     * complex size types, that encode sizes for operands
+     * of type MR (memory or register), for internal use
+     * only. Id space 256 and above.
+     */
+    SZ_BD  = (SZ_B << 8) | SZ_D,
+    SZ_BV  = (SZ_B << 8) | SZ_V,
+    SZ_WD  = (SZ_W << 8) | SZ_D,
+    SZ_WV  = (SZ_W << 8) | SZ_V,
+    SZ_WY  = (SZ_W << 8) | SZ_Y,
+    SZ_DY  = (SZ_D << 8) | SZ_Y,
+    SZ_WO  = (SZ_W << 8) | SZ_O,
+    SZ_DO  = (SZ_D << 8) | SZ_O,
+    SZ_QO  = (SZ_Q << 8) | SZ_O,
+
+} UD_ATTR_PACKED;
+
+
+/* resolve complex size type.
+ */
+static inline enum ud_operand_size
+Mx_mem_size(enum ud_operand_size size)
+{
+    return (size >> 8) & 0xff;
+}
+
+static inline enum ud_operand_size
+Mx_reg_size(enum ud_operand_size size)
+{
+    return size & 0xff;
+}
+
+/* A single operand of an entry in the instruction table. 
+ * (internal use only)
+ */
+struct ud_itab_entry_operand 
+{
+  enum ud_operand_code type;
+  enum ud_operand_size size;
+};
+
+
+/* A single entry in an instruction table. 
+ *(internal use only)
+ */
+struct ud_itab_entry 
+{
+  enum ud_mnemonic_code         mnemonic;
+  struct ud_itab_entry_operand  operand1;
+  struct ud_itab_entry_operand  operand2;
+  struct ud_itab_entry_operand  operand3;
+  uint32_t                      prefix;
+};
+
+struct ud_lookup_table_list_entry {
+    const uint16_t *table;
+    enum ud_table_type type;
+    const char *meta;
+};
+     
+
+
+static inline int
+ud_opcode_field_sext(uint8_t primary_opcode)
+{
+  return (primary_opcode & 0x02) != 0;
+}
+
+extern struct ud_itab_entry ud_itab[];
+extern struct ud_lookup_table_list_entry ud_lookup_table_list[];
+
+#endif /* UD_DECODE_H */
+
+/* vim:cindent
+ * vim:expandtab
+ * vim:ts=4
+ * vim:sw=4
+ */

libudis86/extern.h

+/* udis86 - libudis86/extern.h
+ *
+ * Copyright (c) 2002-2009, 2013 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef UD_EXTERN_H
+#define UD_EXTERN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "types.h"
+
+/* ============================= PUBLIC API ================================= */
+
+extern void ud_init(struct ud*);
+
+extern void ud_set_mode(struct ud*, uint8_t);
+
+extern void ud_set_pc(struct ud*, uint64_t);
+
+extern void ud_set_input_hook(struct ud*, int (*)(struct ud*));
+
+extern void ud_set_input_buffer(struct ud*, const uint8_t*, size_t);
+
+#ifndef __UD_STANDALONE__
+extern void ud_set_input_file(struct ud*, FILE*);
+#endif /* __UD_STANDALONE__ */
+
+extern void ud_set_vendor(struct ud*, unsigned);
+
+extern void ud_set_syntax(struct ud*, void (*)(struct ud*));
+
+extern void ud_input_skip(struct ud*, size_t);
+
+extern int ud_input_end(const struct ud*);
+
+extern unsigned int ud_decode(struct ud*);
+
+extern unsigned int ud_disassemble(struct ud*);
+
+extern void ud_translate_intel(struct ud*);
+
+extern void ud_translate_att(struct ud*);
+
+extern const char* ud_insn_asm(const struct ud* u);
+
+extern const uint8_t* ud_insn_ptr(const struct ud* u);
+
+extern uint64_t ud_insn_off(const struct ud*);
+
+extern const char* ud_insn_hex(struct ud*);
+
+extern unsigned int ud_insn_len(const struct ud* u);
+
+extern const struct ud_operand* ud_insn_opr(const struct ud *u, unsigned int n);
+
+extern int ud_opr_is_sreg(const struct ud_operand *opr);
+
+extern int ud_opr_is_gpr(const struct ud_operand *opr);
+
+extern enum ud_mnemonic_code ud_insn_mnemonic(const struct ud *u);
+
+extern const char* ud_lookup_mnemonic(enum ud_mnemonic_code c);
+
+extern void ud_set_user_opaque_data(struct ud*, void*);
+
+extern void* ud_get_user_opaque_data(const struct ud*);
+
+extern uint64_t ud_insn_sext_imm(const struct ud*, const struct ud_operand*);
+
+extern void ud_set_asm_buffer(struct ud *u, char *buf, size_t size);
+
+extern void ud_set_sym_resolver(struct ud *u, 
+                                const char* (*resolver)(struct ud*, 
+                                                        uint64_t addr,
+                                                        int64_t *offset));
+
+/* ========================================================================== */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* UD_EXTERN_H */

libudis86/itab.h

+#ifndef UD_ITAB_H
+#define UD_ITAB_H
+
+/* itab.h -- generated by udis86:scripts/ud_itab.py, do no edit */
+
+/* ud_table_type -- lookup table types (see decode.c) */
+enum ud_table_type {
+    UD_TAB__OPC_TABLE,
+    UD_TAB__OPC_X87,
+    UD_TAB__OPC_MOD,
+    UD_TAB__OPC_VEX_M,
+    UD_TAB__OPC_VEX_P,
+    UD_TAB__OPC_RM,
+    UD_TAB__OPC_VENDOR,
+    UD_TAB__OPC_OSIZE,
+    UD_TAB__OPC_MODE,
+    UD_TAB__OPC_3DNOW,
+    UD_TAB__OPC_REG,
+    UD_TAB__OPC_ASIZE,
+    UD_TAB__OPC_SSE
+};
+
+/* ud_mnemonic -- mnemonic constants */
+enum ud_mnemonic_code {
+    UD_Iinvalid,
+    UD_I3dnow,
+    UD_Inone,
+    UD_Idb,
+    UD_Ipause,
+    UD_Iaaa,
+    UD_Iaad,
+    UD_Iaam,
+    UD_Iaas,
+    UD_Iadc,
+    UD_Iadd,
+    UD_Iaddpd,
+    UD_Iaddps,
+    UD_Iaddsd,
+    UD_Iaddss,
+    UD_Iand,
+    UD_Iandpd,
+    UD_Iandps,
+    UD_Iandnpd,
+    UD_Iandnps,
+    UD_Iarpl,
+    UD_Imovsxd,
+    UD_Ibound,
+    UD_Ibsf,
+    UD_Ibsr,
+    UD_Ibswap,
+    UD_Ibt,
+    UD_Ibtc,
+    UD_Ibtr,
+    UD_Ibts,
+    UD_Icall,
+    UD_Icbw,
+    UD_Icwde,
+    UD_Icdqe,
+    UD_Iclc,
+    UD_Icld,
+    UD_Iclflush,
+    UD_Iclgi,
+    UD_Icli,
+    UD_Iclts,
+    UD_Icmc,
+    UD_Icmovo,
+    UD_Icmovno,
+    UD_Icmovb,
+    UD_Icmovae,
+    UD_Icmovz,
+    UD_Icmovnz,
+    UD_Icmovbe,
+    UD_Icmova,
+    UD_Icmovs,
+    UD_Icmovns,
+    UD_Icmovp,
+    UD_Icmovnp,
+    UD_Icmovl,
+    UD_Icmovge,
+    UD_Icmovle,
+    UD_Icmovg,
+    UD_Icmp,
+    UD_Icmppd,
+    UD_Icmpps,
+    UD_Icmpsb,
+    UD_Icmpsw,
+    UD_Icmpsd,
+    UD_Icmpsq,
+    UD_Icmpss,
+    UD_Icmpxchg,
+    UD_Icmpxchg8b,
+    UD_Icmpxchg16b,
+    UD_Icomisd,
+    UD_Icomiss,
+    UD_Icpuid,
+    UD_Icvtdq2pd,
+    UD_Icvtdq2ps,
+    UD_Icvtpd2dq,
+    UD_Icvtpd2pi,
+    UD_Icvtpd2ps,
+    UD_Icvtpi2ps,
+    UD_Icvtpi2pd,
+    UD_Icvtps2dq,
+    UD_Icvtps2pi,
+    UD_Icvtps2pd,
+    UD_Icvtsd2si,
+    UD_Icvtsd2ss,
+    UD_Icvtsi2ss,
+    UD_Icvtss2si,
+    UD_Icvtss2sd,
+    UD_Icvttpd2pi,
+    UD_Icvttpd2dq,
+    UD_Icvttps2dq,
+    UD_Icvttps2pi,
+    UD_Icvttsd2si,
+    UD_Icvtsi2sd,
+    UD_Icvttss2si,
+    UD_Icwd,
+    UD_Icdq,
+    UD_Icqo,
+    UD_Idaa,
+    UD_Idas,
+    UD_Idec,
+    UD_Idiv,
+    UD_Idivpd,
+    UD_Idivps,
+    UD_Idivsd,
+    UD_Idivss,
+    UD_Iemms,
+    UD_Ienter,
+    UD_If2xm1,
+    UD_Ifabs,
+    UD_Ifadd,
+    UD_Ifaddp,
+    UD_Ifbld,
+    UD_Ifbstp,
+    UD_Ifchs,
+    UD_Ifclex,
+    UD_Ifcmovb,
+    UD_Ifcmove,
+    UD_Ifcmovbe,
+    UD_Ifcmovu,
+    UD_Ifcmovnb,
+    UD_Ifcmovne,
+    UD_Ifcmovnbe,
+    UD_Ifcmovnu,
+    UD_Ifucomi,
+    UD_Ifcom,
+    UD_Ifcom2,
+    UD_Ifcomp3,
+    UD_Ifcomi,
+    UD_Ifucomip,
+    UD_Ifcomip,
+    UD_Ifcomp,
+    UD_Ifcomp5,
+    UD_Ifcompp,
+    UD_Ifcos,
+    UD_Ifdecstp,
+    UD_Ifdiv,
+    UD_Ifdivp,
+    UD_Ifdivr,
+    UD_Ifdivrp,
+    UD_Ifemms,
+    UD_Iffree,
+    UD_Iffreep,
+    UD_Ificom,
+    UD_Ificomp,
+    UD_Ifild,
+    UD_Ifincstp,
+    UD_Ifninit,
+    UD_Ifiadd,
+    UD_Ifidivr,
+    UD_Ifidiv,
+    UD_Ifisub,
+    UD_Ifisubr,
+    UD_Ifist,
+    UD_Ifistp,
+    UD_Ifisttp,
+    UD_Ifld,
+    UD_Ifld1,
+    UD_Ifldl2t,
+    UD_Ifldl2e,
+    UD_Ifldpi,
+    UD_Ifldlg2,
+    UD_Ifldln2,
+    UD_Ifldz,
+    UD_Ifldcw,
+    UD_Ifldenv,
+    UD_Ifmul,
+    UD_Ifmulp,
+    UD_Ifimul,
+    UD_Ifnop,
+    UD_Ifpatan,
+    UD_Ifprem,
+    UD_Ifprem1,
+    UD_Ifptan,
+    UD_Ifrndint,
+    UD_Ifrstor,
+    UD_Ifnsave,
+    UD_Ifscale,
+    UD_Ifsin,
+    UD_Ifsincos,
+    UD_Ifsqrt,
+    UD_Ifstp,
+    UD_Ifstp1,
+    UD_Ifstp8,
+    UD_Ifstp9,
+    UD_Ifst,
+    UD_Ifnstcw,
+    UD_Ifnstenv,
+    UD_Ifnstsw,
+    UD_Ifsub,
+    UD_Ifsubp,
+    UD_Ifsubr,
+    UD_Ifsubrp,
+    UD_Iftst,
+    UD_Ifucom,
+    UD_Ifucomp,
+    UD_Ifucompp,
+    UD_Ifxam,
+    UD_Ifxch,
+    UD_Ifxch4,
+    UD_Ifxch7,
+    UD_Ifxrstor,
+    UD_Ifxsave,
+    UD_Ifxtract,
+    UD_Ifyl2x,
+    UD_Ifyl2xp1,
+    UD_Ihlt,
+    UD_Iidiv,
+    UD_Iin,
+    UD_Iimul,
+    UD_Iinc,
+    UD_Iinsb,
+    UD_Iinsw,
+    UD_Iinsd,
+    UD_Iint1,
+    UD_Iint3,
+    UD_Iint,
+    UD_Iinto,
+    UD_Iinvd,
+    UD_Iinvept,
+    UD_Iinvlpg,
+    UD_Iinvlpga,
+    UD_Iinvvpid,
+    UD_Iiretw,
+    UD_Iiretd,
+    UD_Iiretq,
+    UD_Ijo,
+    UD_Ijno,
+    UD_Ijb,
+    UD_Ijae,
+    UD_Ijz,
+    UD_Ijnz,
+    UD_Ijbe,
+    UD_Ija,
+    UD_Ijs,
+    UD_Ijns,
+    UD_Ijp,
+    UD_Ijnp,
+    UD_Ijl,
+    UD_Ijge,
+    UD_Ijle,
+    UD_Ijg,
+    UD_Ijcxz,
+    UD_Ijecxz,
+    UD_Ijrcxz,
+    UD_Ijmp,
+    UD_Ilahf,
+    UD_Ilar,
+    UD_Ilddqu,
+    UD_Ildmxcsr,
+    UD_Ilds,
+    UD_Ilea,
+    UD_Iles,
+    UD_Ilfs,
+    UD_Ilgs,
+    UD_Ilidt,
+    UD_Ilss,
+    UD_Ileave,
+    UD_Ilfence,
+    UD_Ilgdt,
+    UD_Illdt,
+    UD_Ilmsw,
+    UD_Ilock,
+    UD_Ilodsb,
+    UD_Ilodsw,
+    UD_Ilodsd,
+    UD_Ilodsq,
+    UD_Iloopne,
+    UD_Iloope,
+    UD_Iloop,
+    UD_Ilsl,
+    UD_Iltr,
+    UD_Imaskmovq,
+    UD_Imaxpd,
+    UD_Imaxps,
+    UD_Imaxsd,
+    UD_Imaxss,
+    UD_Imfence,
+    UD_Iminpd,
+    UD_Iminps,
+    UD_Iminsd,
+    UD_Iminss,
+    UD_Imonitor,
+    UD_Imontmul,
+    UD_Imov,
+    UD_Imovapd,
+    UD_Imovaps,
+    UD_Imovd,
+    UD_Imovhpd,
+    UD_Imovhps,
+    UD_Imovlhps,
+    UD_Imovlpd,
+    UD_Imovlps,
+    UD_Imovhlps,
+    UD_Imovmskpd,
+    UD_Imovmskps,
+    UD_Imovntdq,
+    UD_Imovnti,
+    UD_Imovntpd,
+    UD_Imovntps,
+    UD_Imovntq,
+    UD_Imovq,
+    UD_Imovsb,
+    UD_Imovsw,
+    UD_Imovsd,
+    UD_Imovsq,
+    UD_Imovss,
+    UD_Imovsx,
+    UD_Imovupd,
+    UD_Imovups,
+    UD_Imovzx,
+    UD_Imul,
+    UD_Imulpd,
+    UD_Imulps,
+    UD_Imulsd,
+    UD_Imulss,
+    UD_Imwait,
+    UD_Ineg,
+    UD_Inop,
+    UD_Inot,
+    UD_Ior,
+    UD_Iorpd,
+    UD_Iorps,
+    UD_Iout,
+    UD_Ioutsb,
+    UD_Ioutsw,
+    UD_Ioutsd,
+    UD_Ipacksswb,
+    UD_Ipackssdw,
+    UD_Ipackuswb,
+    UD_Ipaddb,
+    UD_Ipaddw,
+    UD_Ipaddd,
+    UD_Ipaddsb,
+    UD_Ipaddsw,
+    UD_Ipaddusb,
+    UD_Ipaddusw,
+    UD_Ipand,
+    UD_Ipandn,
+    UD_Ipavgb,
+    UD_Ipavgw,
+    UD_Ipcmpeqb,
+    UD_Ipcmpeqw,
+    UD_Ipcmpeqd,
+    UD_Ipcmpgtb,
+    UD_Ipcmpgtw,
+    UD_Ipcmpgtd,
+    UD_Ipextrb,
+    UD_Ipextrd,
+    UD_Ipextrq,
+    UD_Ipextrw,
+    UD_Ipinsrb,
+    UD_Ipinsrw,
+    UD_Ipinsrd,
+    UD_Ipinsrq,
+    UD_Ipmaddwd,
+    UD_Ipmaxsw,
+    UD_Ipmaxub,
+    UD_Ipminsw,
+    UD_Ipminub,
+    UD_Ipmovmskb,
+    UD_Ipmulhuw,
+    UD_Ipmulhw,
+    UD_Ipmullw,
+    UD_Ipop,
+    UD_Ipopa,
+    UD_Ipopad,
+    UD_Ipopfw,
+    UD_Ipopfd,
+    UD_Ipopfq,
+    UD_Ipor,
+    UD_Iprefetch,
+    UD_Iprefetchnta,
+    UD_Iprefetcht0,
+    UD_Iprefetcht1,
+    UD_Iprefetcht2,
+    UD_Ipsadbw,
+    UD_Ipshufw,
+    UD_Ipsllw,
+    UD_Ipslld,
+    UD_Ipsllq,
+    UD_Ipsraw,
+    UD_Ipsrad,
+    UD_Ipsrlw,
+    UD_Ipsrld,
+    UD_Ipsrlq,
+    UD_Ipsubb,
+    UD_Ipsubw,
+    UD_Ipsubd,
+    UD_Ipsubsb,
+    UD_Ipsubsw,
+    UD_Ipsubusb,
+    UD_Ipsubusw,
+    UD_Ipunpckhbw,
+    UD_Ipunpckhwd,
+    UD_Ipunpckhdq,
+    UD_Ipunpcklbw,
+    UD_Ipunpcklwd,
+    UD_Ipunpckldq,
+    UD_Ipi2fw,
+    UD_Ipi2fd,
+    UD_Ipf2iw,
+    UD_Ipf2id,
+    UD_Ipfnacc,
+    UD_Ipfpnacc,
+    UD_Ipfcmpge,
+    UD_Ipfmin,
+    UD_Ipfrcp,
+    UD_Ipfrsqrt,
+    UD_Ipfsub,
+    UD_Ipfadd,
+    UD_Ipfcmpgt,
+    UD_Ipfmax,
+    UD_Ipfrcpit1,
+    UD_Ipfrsqit1,
+    UD_Ipfsubr,
+    UD_Ipfacc,
+    UD_Ipfcmpeq,
+    UD_Ipfmul,
+    UD_Ipfrcpit2,
+    UD_Ipmulhrw,
+    UD_Ipswapd,
+    UD_Ipavgusb,
+    UD_Ipush,
+    UD_Ipusha,
+    UD_Ipushad,
+    UD_Ipushfw,
+    UD_Ipushfd,
+    UD_Ipushfq,
+    UD_Ipxor,
+    UD_Ircl,
+    UD_Ircr,
+    UD_Irol,
+    UD_Iror,
+    UD_Ircpps,
+    UD_Ircpss,
+    UD_Irdmsr,
+    UD_Irdpmc,
+    UD_Irdtsc,
+    UD_Irdtscp,
+    UD_Irepne,
+    UD_Irep,
+    UD_Iret,
+    UD_Iretf,
+    UD_Irsm,
+    UD_Irsqrtps,
+    UD_Irsqrtss,
+    UD_Isahf,
+    UD_Isalc,
+    UD_Isar,
+    UD_Ishl,
+    UD_Ishr,
+    UD_Isbb,
+    UD_Iscasb,
+    UD_Iscasw,
+    UD_Iscasd,
+    UD_Iscasq,
+    UD_Iseto,
+    UD_Isetno,
+    UD_Isetb,
+    UD_Isetae,
+    UD_Isetz,
+    UD_Isetnz,
+    UD_Isetbe,
+    UD_Iseta,
+    UD_Isets,
+    UD_Isetns,
+    UD_Isetp,
+    UD_Isetnp,
+    UD_Isetl,
+    UD_Isetge,
+    UD_Isetle,
+    UD_Isetg,
+    UD_Isfence,
+    UD_Isgdt,
+    UD_Ishld,
+    UD_Ishrd,
+    UD_Ishufpd,
+    UD_Ishufps,
+    UD_Isidt,
+    UD_Isldt,
+    UD_Ismsw,
+    UD_Isqrtps,
+    UD_Isqrtpd,
+    UD_Isqrtsd,
+    UD_Isqrtss,
+    UD_Istc,
+    UD_Istd,
+    UD_Istgi,
+    UD_Isti,
+    UD_Iskinit,
+    UD_Istmxcsr,
+    UD_Istosb,
+    UD_Istosw,
+    UD_Istosd,
+    UD_Istosq,
+    UD_Istr,
+    UD_Isub,
+    UD_Isubpd,
+    UD_Isubps,
+    UD_Isubsd,
+    UD_Isubss,
+    UD_Iswapgs,
+    UD_Isyscall,
+    UD_Isysenter,
+    UD_Isysexit,
+    UD_Isysret,
+    UD_Itest,
+    UD_Iucomisd,
+    UD_Iucomiss,
+    UD_Iud2,
+    UD_Iunpckhpd,
+    UD_Iunpckhps,
+    UD_Iunpcklps,
+    UD_Iunpcklpd,
+    UD_Iverr,
+    UD_Iverw,
+    UD_Ivmcall,
+    UD_Ivmclear,
+    UD_Ivmxon,
+    UD_Ivmptrld,
+    UD_Ivmptrst,
+    UD_Ivmlaunch,
+    UD_Ivmresume,
+    UD_Ivmxoff,
+    UD_Ivmread,
+    UD_Ivmwrite,
+    UD_Ivmrun,
+    UD_Ivmmcall,
+    UD_Ivmload,
+    UD_Ivmsave,
+    UD_Iwait,
+    UD_Iwbinvd,
+    UD_Iwrmsr,
+    UD_Ixadd,
+    UD_Ixchg,
+    UD_Ixgetbv,
+    UD_Ixlatb,
+    UD_Ixor,
+    UD_Ixorpd,
+    UD_Ixorps,
+    UD_Ixcryptecb,
+    UD_Ixcryptcbc,
+    UD_Ixcryptctr,
+    UD_Ixcryptcfb,
+    UD_Ixcryptofb,
+    UD_Ixrstor,
+    UD_Ixsave,
+    UD_Ixsetbv,
+    UD_Ixsha1,
+    UD_Ixsha256,
+    UD_Ixstore,
+    UD_Iaesdec,
+    UD_Iaesdeclast,
+    UD_Iaesenc,
+    UD_Iaesenclast,
+    UD_Iaesimc,
+    UD_Iaeskeygenassist,
+    UD_Ipclmulqdq,
+    UD_Igetsec,
+    UD_Imovdqa,
+    UD_Imaskmovdqu,
+    UD_Imovdq2q,
+    UD_Imovdqu,
+    UD_Imovq2dq,
+    UD_Ipaddq,
+    UD_Ipsubq,
+    UD_Ipmuludq,
+    UD_Ipshufhw,
+    UD_Ipshuflw,
+    UD_Ipshufd,
+    UD_Ipslldq,
+    UD_Ipsrldq,
+    UD_Ipunpckhqdq,
+    UD_Ipunpcklqdq,
+    UD_Iaddsubpd,
+    UD_Iaddsubps,
+    UD_Ihaddpd,
+    UD_Ihaddps,
+    UD_Ihsubpd,
+    UD_Ihsubps,
+    UD_Imovddup,
+    UD_Imovshdup,
+    UD_Imovsldup,
+    UD_Ipabsb,
+    UD_Ipabsw,
+    UD_Ipabsd,
+    UD_Ipshufb,
+    UD_Iphaddw,
+    UD_Iphaddd,
+    UD_Iphaddsw,
+    UD_Ipmaddubsw,
+    UD_Iphsubw,
+    UD_Iphsubd,
+    UD_Iphsubsw,
+    UD_Ipsignb,
+    UD_Ipsignd,
+    UD_Ipsignw,
+    UD_Ipmulhrsw,
+    UD_Ipalignr,
+    UD_Ipblendvb,
+    UD_Ipmuldq,
+    UD_Ipminsb,
+    UD_Ipminsd,
+    UD_Ipminuw,
+    UD_Ipminud,
+    UD_Ipmaxsb,
+    UD_Ipmaxsd,
+    UD_Ipmaxud,
+    UD_Ipmaxuw,
+    UD_Ipmulld,
+    UD_Iphminposuw,
+    UD_Iroundps,
+    UD_Iroundpd,
+    UD_Iroundss,
+    UD_Iroundsd,
+    UD_Iblendpd,
+    UD_Ipblendw,
+    UD_Iblendps,
+    UD_Iblendvpd,
+    UD_Iblendvps,
+    UD_Idpps,
+    UD_Idppd,
+    UD_Impsadbw,
+    UD_Iextractps,
+    UD_Iinsertps,
+    UD_Imovntdqa,
+    UD_Ipackusdw,
+    UD_Ipmovsxbw,
+    UD_Ipmovsxbd,
+    UD_Ipmovsxbq,
+    UD_Ipmovsxwd,
+    UD_Ipmovsxwq,
+    UD_Ipmovsxdq,
+    UD_Ipmovzxbw,
+    UD_Ipmovzxbd,
+    UD_Ipmovzxbq,
+    UD_Ipmovzxwd,
+    UD_Ipmovzxwq,
+    UD_Ipmovzxdq,
+    UD_Ipcmpeqq,
+    UD_Ipopcnt,
+    UD_Iptest,
+    UD_Ipcmpestri,
+    UD_Ipcmpestrm,
+    UD_Ipcmpgtq,
+    UD_Ipcmpistri,
+    UD_Ipcmpistrm,
+    UD_Imovbe,
+    UD_Icrc32,
+    UD_MAX_MNEMONIC_CODE
+} UD_ATTR_PACKED;
+
+extern const char * ud_mnemonics_str[];
+
+#endif /* UD_ITAB_H */

libudis86/syn-att.c

+/* udis86 - libudis86/syn-att.c
+ *
+ * Copyright (c) 2002-2009 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#include "types.h"
+#include "extern.h"
+#include "decode.h"
+#include "itab.h"
+#include "syn.h"
+#include "udint.h"
+
+/* -----------------------------------------------------------------------------
+ * opr_cast() - Prints an operand cast.
+ * -----------------------------------------------------------------------------
+ */
+static void 
+opr_cast(struct ud* u, struct ud_operand* op)
+{
+  switch(op->size) {
+  case 16 : case 32 :
+    ud_asmprintf(u, "*");   break;
+  default: break;
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * gen_operand() - Generates assembly output for each operand.
+ * -----------------------------------------------------------------------------
+ */
+static void 
+gen_operand(struct ud* u, struct ud_operand* op)
+{
+  switch(op->type) {
+  case UD_OP_CONST:
+    ud_asmprintf(u, "$0x%x", op->lval.udword);
+    break;
+
+  case UD_OP_REG:
+    ud_asmprintf(u, "%%%s", ud_reg_tab[op->base - UD_R_AL]);
+    break;
+
+  case UD_OP_MEM:
+    if (u->br_far) {
+        opr_cast(u, op);
+    }
+    if (u->pfx_seg) {
+      ud_asmprintf(u, "%%%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]);
+    }
+    if (op->offset != 0) { 
+      ud_syn_print_mem_disp(u, op, 0);
+    }
+    if (op->base) {
+      ud_asmprintf(u, "(%%%s", ud_reg_tab[op->base - UD_R_AL]);
+    }
+    if (op->index) {
+      if (op->base) {
+        ud_asmprintf(u, ",");
+      } else {
+        ud_asmprintf(u, "(");
+      }
+      ud_asmprintf(u, "%%%s", ud_reg_tab[op->index - UD_R_AL]);
+    }
+    if (op->scale) {
+      ud_asmprintf(u, ",%d", op->scale);
+    }
+    if (op->base || op->index) {
+      ud_asmprintf(u, ")");
+    }
+    break;
+
+  case UD_OP_IMM:
+    ud_asmprintf(u, "$");
+    ud_syn_print_imm(u, op);
+    break;
+
+  case UD_OP_JIMM:
+    ud_syn_print_addr(u, ud_syn_rel_target(u, op));
+    break;
+
+  case UD_OP_PTR:
+    switch (op->size) {
+      case 32:
+        ud_asmprintf(u, "$0x%x, $0x%x", op->lval.ptr.seg, 
+          op->lval.ptr.off & 0xFFFF);
+        break;
+      case 48:
+        ud_asmprintf(u, "$0x%x, $0x%x", op->lval.ptr.seg, 
+          op->lval.ptr.off);
+        break;
+    }
+    break;
+      
+  default: return;
+  }
+}
+
+/* =============================================================================
+ * translates to AT&T syntax 
+ * =============================================================================
+ */
+extern void 
+ud_translate_att(struct ud *u)
+{
+  int size = 0;
+  int star = 0;
+
+  /* check if P_OSO prefix is used */
+  if (! P_OSO(u->itab_entry->prefix) && u->pfx_opr) {
+  switch (u->dis_mode) {
+    case 16: 
+      ud_asmprintf(u, "o32 ");
+      break;
+    case 32:
+    case 64:
+      ud_asmprintf(u, "o16 ");
+      break;
+  }
+  }
+
+  /* check if P_ASO prefix was used */
+  if (! P_ASO(u->itab_entry->prefix) && u->pfx_adr) {
+  switch (u->dis_mode) {
+    case 16: 
+      ud_asmprintf(u, "a32 ");
+      break;
+    case 32:
+      ud_asmprintf(u, "a16 ");
+      break;
+    case 64:
+      ud_asmprintf(u, "a32 ");
+      break;
+  }
+  }
+
+  if (u->pfx_lock)
+    ud_asmprintf(u,  "lock ");
+  if (u->pfx_rep) {
+    ud_asmprintf(u, "rep ");
+  } else if (u->pfx_rep) {
+    ud_asmprintf(u, "repe ");
+  } else if (u->pfx_repne) {
+    ud_asmprintf(u, "repne ");
+  }
+
+  /* special instructions */
+  switch (u->mnemonic) {
+  case UD_Iretf: 
+    ud_asmprintf(u, "lret "); 
+    break;
+  case UD_Idb:
+    ud_asmprintf(u, ".byte 0x%x", u->operand[0].lval.ubyte);
+    return;
+  case UD_Ijmp:
+  case UD_Icall:
+    if (u->br_far) ud_asmprintf(u,  "l");
+        if (u->operand[0].type == UD_OP_REG) {
+          star = 1;
+        }
+    ud_asmprintf(u, "%s", ud_lookup_mnemonic(u->mnemonic));
+    break;
+  case UD_Ibound:
+  case UD_Ienter:
+    if (u->operand[0].type != UD_NONE)
+      gen_operand(u, &u->operand[0]);
+    if (u->operand[1].type != UD_NONE) {
+      ud_asmprintf(u, ",");
+      gen_operand(u, &u->operand[1]);
+    }
+    return;
+  default:
+    ud_asmprintf(u, "%s", ud_lookup_mnemonic(u->mnemonic));
+  }
+
+  if (size == 8)
+  ud_asmprintf(u, "b");
+  else if (size == 16)
+  ud_asmprintf(u, "w");
+  else if (size == 64)
+  ud_asmprintf(u, "q");
+
+  if (star) {
+    ud_asmprintf(u, " *");
+  } else {
+    ud_asmprintf(u, " ");
+  }
+
+  if (u->operand[2].type != UD_NONE) {
+  gen_operand(u, &u->operand[2]);
+  ud_asmprintf(u, ", ");
+  }
+
+  if (u->operand[1].type != UD_NONE) {
+  gen_operand(u, &u->operand[1]);
+  ud_asmprintf(u, ", ");
+  }
+
+  if (u->operand[0].type != UD_NONE)
+  gen_operand(u, &u->operand[0]);
+}
+
+/*
+vim: set ts=2 sw=2 expandtab
+*/

libudis86/syn-intel.c

+/* udis86 - libudis86/syn-intel.c
+ *
+ * Copyright (c) 2002-2013 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#include "types.h"
+#include "extern.h"
+#include "decode.h"
+#include "itab.h"
+#include "syn.h"
+#include "udint.h"
+
+/* -----------------------------------------------------------------------------
+ * opr_cast() - Prints an operand cast.
+ * -----------------------------------------------------------------------------
+ */
+static void 
+opr_cast(struct ud* u, struct ud_operand* op)
+{
+  if (u->br_far) {
+    ud_asmprintf(u, "far "); 
+  }
+  switch(op->size) {
+  case  8: ud_asmprintf(u, "byte " ); break;
+  case 16: ud_asmprintf(u, "word " ); break;
+  case 32: ud_asmprintf(u, "dword "); break;
+  case 64: ud_asmprintf(u, "qword "); break;
+  case 80: ud_asmprintf(u, "tword "); break;
+  default: break;
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * gen_operand() - Generates assembly output for each operand.
+ * -----------------------------------------------------------------------------
+ */
+static void gen_operand(struct ud* u, struct ud_operand* op, int syn_cast)
+{
+  switch(op->type) {
+  case UD_OP_REG:
+    ud_asmprintf(u, "%s", ud_reg_tab[op->base - UD_R_AL]);
+    break;
+
+  case UD_OP_MEM:
+    if (syn_cast) {
+      opr_cast(u, op);
+    }
+    ud_asmprintf(u, "[");
+    if (u->pfx_seg) {
+      ud_asmprintf(u, "%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]);
+    }
+    if (op->base) {
+      ud_asmprintf(u, "%s", ud_reg_tab[op->base - UD_R_AL]);
+    }
+    if (op->index) {
+      ud_asmprintf(u, "%s%s", op->base != UD_NONE? "+" : "",
+                              ud_reg_tab[op->index - UD_R_AL]);
+      if (op->scale) {
+        ud_asmprintf(u, "*%d", op->scale);
+      }
+    }
+    if (op->offset != 0) {
+      ud_syn_print_mem_disp(u, op, (op->base  != UD_NONE || 
+                                    op->index != UD_NONE) ? 1 : 0);
+    }
+    ud_asmprintf(u, "]");
+    break;
+      
+  case UD_OP_IMM:
+    ud_syn_print_imm(u, op);
+    break;
+
+
+  case UD_OP_JIMM:
+    ud_syn_print_addr(u, ud_syn_rel_target(u, op));
+    break;
+
+  case UD_OP_PTR:
+    switch (op->size) {
+      case 32:
+        ud_asmprintf(u, "word 0x%x:0x%x", op->lval.ptr.seg, 
+          op->lval.ptr.off & 0xFFFF);
+        break;
+      case 48:
+        ud_asmprintf(u, "dword 0x%x:0x%x", op->lval.ptr.seg, 
+          op->lval.ptr.off);
+        break;
+    }
+    break;
+
+  case UD_OP_CONST:
+    if (syn_cast) opr_cast(u, op);
+    ud_asmprintf(u, "%d", op->lval.udword);
+    break;
+
+  default: return;
+  }
+}
+
+/* =============================================================================
+ * translates to intel syntax 
+ * =============================================================================
+ */
+extern void
+ud_translate_intel(struct ud* u)
+{
+  /* check if P_OSO prefix is used */
+  if (!P_OSO(u->itab_entry->prefix) && u->pfx_opr) {
+    switch (u->dis_mode) {
+    case 16: ud_asmprintf(u, "o32 "); break;
+    case 32:
+    case 64: ud_asmprintf(u, "o16 "); break;
+    }
+  }
+
+  /* check if P_ASO prefix was used */
+  if (!P_ASO(u->itab_entry->prefix) && u->pfx_adr) {
+    switch (u->dis_mode) {
+    case 16: ud_asmprintf(u, "a32 "); break;
+    case 32: ud_asmprintf(u, "a16 "); break;
+    case 64: ud_asmprintf(u, "a32 "); break;
+    }
+  }
+
+  if (u->pfx_seg &&
+      u->operand[0].type != UD_OP_MEM &&
+      u->operand[1].type != UD_OP_MEM ) {
+    ud_asmprintf(u, "%s ", ud_reg_tab[u->pfx_seg - UD_R_AL]);
+  }
+
+  if (u->pfx_lock) {
+    ud_asmprintf(u, "lock ");
+  }
+  if (u->pfx_rep) {
+    ud_asmprintf(u, "rep ");
+  } else if (u->pfx_repe) {
+    ud_asmprintf(u, "repe ");
+  } else if (u->pfx_repne) {
+    ud_asmprintf(u, "repne ");
+  }
+
+  /* print the instruction mnemonic */
+  ud_asmprintf(u, "%s", ud_lookup_mnemonic(u->mnemonic));
+
+  if (u->operand[0].type != UD_NONE) {
+    int cast = 0;
+    ud_asmprintf(u, " ");
+    if (u->operand[0].type == UD_OP_MEM) {
+      if (u->operand[1].type == UD_OP_IMM   ||
+          u->operand[1].type == UD_OP_CONST ||
+          u->operand[1].type == UD_NONE     ||
+          (u->operand[0].size != u->operand[1].size && 
+           u->operand[1].type != UD_OP_REG)) {
+          cast = 1;
+      } else if (u->operand[1].type == UD_OP_REG &&
+                 u->operand[1].base == UD_R_CL) {
+          switch (u->mnemonic) {
+          case UD_Ircl:
+          case UD_Irol:
+          case UD_Iror:
+          case UD_Ircr:
+          case UD_Ishl:
+          case UD_Ishr:
+          case UD_Isar:
+              cast = 1;
+              break;
+          default: break;
+          }
+      }
+    }
+    gen_operand(u, &u->operand[0], cast);
+  }
+
+  if (u->operand[1].type != UD_NONE) {
+    int cast = 0;
+    ud_asmprintf(u, ", ");
+    if (u->operand[1].type == UD_OP_MEM &&
+        u->operand[0].size != u->operand[1].size && 
+        !ud_opr_is_sreg(&u->operand[0])) {
+      cast = 1;
+    }
+    gen_operand(u, &u->operand[1], cast);
+  }
+
+  if (u->operand[2].type != UD_NONE) {
+    ud_asmprintf(u, ", ");
+    gen_operand(u, &u->operand[2], 0);
+  }
+}
+
+/*
+vim: set ts=2 sw=2 expandtab
+*/

libudis86/syn.c

+/* udis86 - libudis86/syn.c
+ *
+ * Copyright (c) 2002-2013 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#include "types.h"
+#include "decode.h"
+#include "syn.h"
+#include "udint.h"
+
+/* -----------------------------------------------------------------------------
+ * Intel Register Table - Order Matters (types.h)!
+ * -----------------------------------------------------------------------------
+ */
+const char* ud_reg_tab[] = 
+{
+  "al",   "cl",   "dl",   "bl",
+  "ah",   "ch",   "dh",   "bh",
+  "spl",  "bpl",    "sil",    "dil",
+  "r8b",  "r9b",    "r10b",   "r11b",
+  "r12b", "r13b",   "r14b",   "r15b",
+
+  "ax",   "cx",   "dx",   "bx",
+  "sp",   "bp",   "si",   "di",
+  "r8w",  "r9w",    "r10w",   "r11w",
+  "r12w", "r13w"  , "r14w",   "r15w",
+  
+  "eax",  "ecx",    "edx",    "ebx",
+  "esp",  "ebp",    "esi",    "edi",
+  "r8d",  "r9d",    "r10d",   "r11d",
+  "r12d", "r13d",   "r14d",   "r15d",
+  
+  "rax",  "rcx",    "rdx",    "rbx",
+  "rsp",  "rbp",    "rsi",    "rdi",
+  "r8",   "r9",   "r10",    "r11",
+  "r12",  "r13",    "r14",    "r15",
+
+  "es",   "cs",   "ss",   "ds",
+  "fs",   "gs", 
+
+  "cr0",  "cr1",    "cr2",    "cr3",
+  "cr4",  "cr5",    "cr6",    "cr7",
+  "cr8",  "cr9",    "cr10",   "cr11",
+  "cr12", "cr13",   "cr14",   "cr15",
+  
+  "dr0",  "dr1",    "dr2",    "dr3",
+  "dr4",  "dr5",    "dr6",    "dr7",
+  "dr8",  "dr9",    "dr10",   "dr11",
+  "dr12", "dr13",   "dr14",   "dr15",
+
+  "mm0",  "mm1",    "mm2",    "mm3",
+  "mm4",  "mm5",    "mm6",    "mm7",
+
+  "st0",  "st1",    "st2",    "st3",
+  "st4",  "st5",    "st6",    "st7", 
+
+  "xmm0", "xmm1",   "xmm2",   "xmm3",
+  "xmm4", "xmm5",   "xmm6",   "xmm7",
+  "xmm8", "xmm9",   "xmm10",  "xmm11",
+  "xmm12",  "xmm13",  "xmm14",  "xmm15",
+
+  "rip"
+};
+
+
+uint64_t
+ud_syn_rel_target(struct ud *u, struct ud_operand *opr)
+{
+  const uint64_t trunc_mask = 0xffffffffffffffffull >> (64 - u->opr_mode);
+  switch (opr->size) {
+  case 8 : return (u->pc + opr->lval.sbyte)  & trunc_mask;
+  case 16: return (u->pc + opr->lval.sword)  & trunc_mask;
+  case 32: return (u->pc + opr->lval.sdword) & trunc_mask;
+  default: UD_ASSERT(!"invalid relative offset size.");
+    return 0ull;
+  }
+}
+
+
+/*
+ * asmprintf
+ *    Printf style function for printing translated assembly
+ *    output. Returns the number of characters written and
+ *    moves the buffer pointer forward. On an overflow,
+ *    returns a negative number and truncates the output.
+ */
+int
+ud_asmprintf(struct ud *u, const char *fmt, ...)
+{
+  int ret;
+  int avail;
+  va_list ap;
+  va_start(ap, fmt);
+  avail = u->asm_buf_size - u->asm_buf_fill - 1 /* nullchar */;
+  ret = vsnprintf((char*) u->asm_buf + u->asm_buf_fill, avail, fmt, ap);
+  if (ret < 0 || ret > avail) {
+      u->asm_buf_fill = u->asm_buf_size - 1;
+  } else {
+      u->asm_buf_fill += ret;
+  }
+  va_end(ap);
+  return ret;
+}
+
+
+void
+ud_syn_print_addr(struct ud *u, uint64_t addr)
+{
+  const char *name = NULL;
+  if (u->sym_resolver) {
+    int64_t offset = 0;
+    name = u->sym_resolver(u, addr, &offset);
+    if (name) {
+      if (offset) {
+        ud_asmprintf(u, "%s%+" FMT64 "d", name, offset);
+      } else {
+        ud_asmprintf(u, "%s", name);
+      }
+      return;
+    }
+  }
+  ud_asmprintf(u, "0x%" FMT64 "x", addr);
+}
+
+
+void
+ud_syn_print_imm(struct ud* u, const struct ud_operand *op)
+{
+  uint64_t v;
+  if (op->_oprcode == OP_sI && op->size != u->opr_mode) {
+    if (op->size == 8) {
+      v = (int64_t)op->lval.sbyte;
+    } else {
+      UD_ASSERT(op->size == 32);
+      v = (int64_t)op->lval.sdword;
+    }
+    if (u->opr_mode < 64) {
+      v = v & ((1ull << u->opr_mode) - 1ull);
+    }
+  } else {
+    switch (op->size) {
+    case 8 : v = op->lval.ubyte;  break;
+    case 16: v = op->lval.uword;  break;
+    case 32: v = op->lval.udword; break;
+    case 64: v = op->lval.uqword; break;
+    default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */
+    }
+  }
+  ud_asmprintf(u, "0x%" FMT64 "x", v);
+}
+
+
+void
+ud_syn_print_mem_disp(struct ud* u, const struct ud_operand *op, int sign)
+{
+  UD_ASSERT(op->offset != 0);
+ if (op->base == UD_NONE && op->index == UD_NONE) {
+    uint64_t v;
+    UD_ASSERT(op->scale == UD_NONE && op->offset != 8);
+    /* unsigned mem-offset */
+    switch (op->offset) {
+    case 16: v = op->lval.uword;  break;
+    case 32: v = op->lval.udword; break;
+    case 64: v = op->lval.uqword; break;
+    default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */
+    }
+    ud_asmprintf(u, "0x%" FMT64 "x", v);
+  } else {
+    int64_t v;
+    UD_ASSERT(op->offset != 64);
+    switch (op->offset) {
+    case 8 : v = op->lval.sbyte;  break;
+    case 16: v = op->lval.sword;  break;
+    case 32: v = op->lval.sdword; break;
+    default: UD_ASSERT(!"invalid offset"); v = 0; /* keep cc happy */
+    }
+    if (v < 0) {
+      ud_asmprintf(u, "-0x%" FMT64 "x", -v);
+    } else if (v > 0) {
+      ud_asmprintf(u, "%s0x%" FMT64 "x", sign? "+" : "", v);
+    }
+  }
+}
+
+/*
+vim: set ts=2 sw=2 expandtab
+*/

libudis86/syn.h

+/* udis86 - libudis86/syn.h
+ *
+ * Copyright (c) 2002-2009
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef UD_SYN_H
+#define UD_SYN_H
+
+#include "types.h"
+#ifndef __UD_STANDALONE__
+# include <stdarg.h>
+#endif /* __UD_STANDALONE__ */
+
+extern const char* ud_reg_tab[];
+
+uint64_t ud_syn_rel_target(struct ud*, struct ud_operand*);
+
+#ifdef __GNUC__
+int ud_asmprintf(struct ud *u, const char *fmt, ...)
+    __attribute__ ((format (printf, 2, 3)));
+#else
+int ud_asmprintf(struct ud *u, const char *fmt, ...);
+#endif
+
+void ud_syn_print_addr(struct ud *u, uint64_t addr);
+void ud_syn_print_imm(struct ud* u, const struct ud_operand *op);
+void ud_syn_print_mem_disp(struct ud* u, const struct ud_operand *, int sign);
+
+#endif /* UD_SYN_H */
+
+/*
+vim: set ts=2 sw=2 expandtab
+*/

libudis86/types.h

+/* udis86 - libudis86/types.h
+ *
+ * Copyright (c) 2002-2013 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef UD_TYPES_H
+#define UD_TYPES_H
+
+#ifdef __KERNEL__
+  /* -D__KERNEL__ is automatically passed on the command line when
+     building something as part of the Linux kernel */
+# include <linux/kernel.h>
+# include <linux/string.h>
+# ifndef __UD_STANDALONE__
+#  define __UD_STANDALONE__ 1
+#endif
+#endif /* __KERNEL__ */
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+# include <stdint.h>
+# include <stdio.h>
+# define inline __inline /* MS Visual Studio requires __inline 
+                            instead of inline for C code */
+#elif !defined(__UD_STANDALONE__)
+# include <stdio.h>
+# include <inttypes.h>
+#endif /* !__UD_STANDALONE__ */
+
+/* gcc specific extensions */
+#ifdef __GNUC__
+# define UD_ATTR_PACKED __attribute__((packed))
+#else
+# define UD_ATTR_PACKED
+#endif /* UD_ATTR_PACKED */
+
+
+/* -----------------------------------------------------------------------------
+ * All possible "types" of objects in udis86. Order is Important!
+ * -----------------------------------------------------------------------------
+ */
+enum ud_type
+{
+  UD_NONE,
+
+  /* 8 bit GPRs */
+  UD_R_AL,  UD_R_CL,  UD_R_DL,  UD_R_BL,
+  UD_R_AH,  UD_R_CH,  UD_R_DH,  UD_R_BH,
+  UD_R_SPL, UD_R_BPL, UD_R_SIL, UD_R_DIL,
+  UD_R_R8B, UD_R_R9B, UD_R_R10B,  UD_R_R11B,
+  UD_R_R12B,  UD_R_R13B,  UD_R_R14B,  UD_R_R15B,
+
+  /* 16 bit GPRs */
+  UD_R_AX,  UD_R_CX,  UD_R_DX,  UD_R_BX,
+  UD_R_SP,  UD_R_BP,  UD_R_SI,  UD_R_DI,
+  UD_R_R8W, UD_R_R9W, UD_R_R10W,  UD_R_R11W,
+  UD_R_R12W,  UD_R_R13W,  UD_R_R14W,  UD_R_R15W,
+  
+  /* 32 bit GPRs */
+  UD_R_EAX, UD_R_ECX, UD_R_EDX, UD_R_EBX,
+  UD_R_ESP, UD_R_EBP, UD_R_ESI, UD_R_EDI,
+  UD_R_R8D, UD_R_R9D, UD_R_R10D,  UD_R_R11D,
+  UD_R_R12D,  UD_R_R13D,  UD_R_R14D,  UD_R_R15D,
+  
+  /* 64 bit GPRs */
+  UD_R_RAX, UD_R_RCX, UD_R_RDX, UD_R_RBX,
+  UD_R_RSP, UD_R_RBP, UD_R_RSI, UD_R_RDI,
+  UD_R_R8,  UD_R_R9,  UD_R_R10, UD_R_R11,
+  UD_R_R12, UD_R_R13, UD_R_R14, UD_R_R15,
+
+  /* segment registers */
+  UD_R_ES,  UD_R_CS,  UD_R_SS,  UD_R_DS,
+  UD_R_FS,  UD_R_GS,  
+
+  /* control registers*/
+  UD_R_CR0, UD_R_CR1, UD_R_CR2, UD_R_CR3,
+  UD_R_CR4, UD_R_CR5, UD_R_CR6, UD_R_CR7,
+  UD_R_CR8, UD_R_CR9, UD_R_CR10,  UD_R_CR11,
+  UD_R_CR12,  UD_R_CR13,  UD_R_CR14,  UD_R_CR15,
+  
+  /* debug registers */
+  UD_R_DR0, UD_R_DR1, UD_R_DR2, UD_R_DR3,
+  UD_R_DR4, UD_R_DR5, UD_R_DR6, UD_R_DR7,
+  UD_R_DR8, UD_R_DR9, UD_R_DR10,  UD_R_DR11,
+  UD_R_DR12,  UD_R_DR13,  UD_R_DR14,  UD_R_DR15,
+
+  /* mmx registers */
+  UD_R_MM0, UD_R_MM1, UD_R_MM2, UD_R_MM3,
+  UD_R_MM4, UD_R_MM5, UD_R_MM6, UD_R_MM7,
+
+  /* x87 registers */
+  UD_R_ST0, UD_R_ST1, UD_R_ST2, UD_R_ST3,
+  UD_R_ST4, UD_R_ST5, UD_R_ST6, UD_R_ST7, 
+
+  /* extended multimedia registers */
+  UD_R_XMM0,  UD_R_XMM1,  UD_R_XMM2,  UD_R_XMM3,
+  UD_R_XMM4,  UD_R_XMM5,  UD_R_XMM6,  UD_R_XMM7,
+  UD_R_XMM8,  UD_R_XMM9,  UD_R_XMM10, UD_R_XMM11,
+  UD_R_XMM12, UD_R_XMM13, UD_R_XMM14, UD_R_XMM15,
+
+  UD_R_RIP,
+
+  /* Operand Types */
+  UD_OP_REG,  UD_OP_MEM,  UD_OP_PTR,  UD_OP_IMM,  
+  UD_OP_JIMM, UD_OP_CONST
+};
+
+#include "itab.h"
+
+union ud_lval {
+  int8_t     sbyte;
+  uint8_t    ubyte;
+  int16_t    sword;
+  uint16_t   uword;
+  int32_t    sdword;
+  uint32_t   udword;
+  int64_t    sqword;
+  uint64_t   uqword;
+  struct {
+    uint16_t seg;
+    uint32_t off;
+  } ptr;
+};
+
+/* -----------------------------------------------------------------------------
+ * struct ud_operand - Disassembled instruction Operand.
+ * -----------------------------------------------------------------------------
+ */
+struct ud_operand {
+  enum ud_type    type;
+  uint8_t         size;
+  enum ud_type    base;
+  enum ud_type    index;
+  uint8_t         scale;  
+  uint8_t         offset;
+  union ud_lval   lval;
+  /*
+   * internal use only
+   */
+  uint64_t        _legacy; /* this will be removed in 1.8 */
+  uint8_t         _oprcode;
+};
+
+/* -----------------------------------------------------------------------------
+ * struct ud - The udis86 object.
+ * -----------------------------------------------------------------------------
+ */
+struct ud
+{
+  /*
+   * input buffering
+   */
+  int       (*inp_hook) (struct ud*);
+#ifndef __UD_STANDALONE__
+  FILE*     inp_file;
+#endif
+  const uint8_t* inp_buf;
+  size_t    inp_buf_size;
+  size_t    inp_buf_index;
+  uint8_t   inp_curr;
+  size_t    inp_ctr;
+  uint8_t   inp_sess[64];
+  int       inp_end;
+
+  void      (*translator)(struct ud*);
+  uint64_t  insn_offset;
+  char      insn_hexcode[64];
+
+  /*
+   * Assembly output buffer
+   */
+  char     *asm_buf;
+  size_t    asm_buf_size;
+  size_t    asm_buf_fill;
+  char      asm_buf_int[128];
+
+  /*
+   * Symbol resolver for use in the translation phase.
+   */
+  const char* (*sym_resolver)(struct ud*, uint64_t addr, int64_t *offset);
+
+  uint8_t   dis_mode;
+  uint64_t  pc;
+  uint8_t   vendor;
+  enum ud_mnemonic_code mnemonic;
+  struct ud_operand operand[3];
+  uint8_t   error;
+  uint8_t   pfx_rex;
+  uint8_t   pfx_seg;
+  uint8_t   pfx_opr;
+  uint8_t   pfx_adr;
+  uint8_t   pfx_lock;
+  uint8_t   pfx_str;
+  uint8_t   pfx_rep;
+  uint8_t   pfx_repe;
+  uint8_t   pfx_repne;
+  uint8_t   opr_mode;
+  uint8_t   adr_mode;
+  uint8_t   br_far;
+  uint8_t   br_near;
+  uint8_t   have_modrm;
+  uint8_t   modrm;
+  uint8_t   primary_opcode;
+  void *    user_opaque_data;
+  struct ud_itab_entry * itab_entry;
+  struct ud_lookup_table_list_entry *le;
+};
+
+/* -----------------------------------------------------------------------------
+ * Type-definitions
+ * -----------------------------------------------------------------------------
+ */
+typedef enum ud_type          ud_type_t;
+typedef enum ud_mnemonic_code ud_mnemonic_code_t;
+
+typedef struct ud             ud_t;
+typedef struct ud_operand     ud_operand_t;
+
+#define UD_SYN_INTEL          ud_translate_intel
+#define UD_SYN_ATT            ud_translate_att
+#define UD_EOI                (-1)
+#define UD_INP_CACHE_SZ       32
+#define UD_VENDOR_AMD         0
+#define UD_VENDOR_INTEL       1
+#define UD_VENDOR_ANY         2
+
+#endif
+
+/*
+vim: set ts=2 sw=2 expandtab
+*/

libudis86/udint.h

+/* udis86 - libudis86/udint.h -- definitions for internal use only
+ * 
+ * Copyright (c) 2002-2009 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef _UDINT_H_
+#define _UDINT_H_
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#if defined(UD_DEBUG) && HAVE_ASSERT_H
+# include <assert.h>
+# define UD_ASSERT(_x) assert(_x)
+#else
+# define UD_ASSERT(_x)
+#endif /* !HAVE_ASSERT_H */
+
+#if defined(UD_DEBUG)
+  #define UDERR(u, msg) \
+    do { \
+      (u)->error = 1; \
+      fprintf(stderr, "decode-error: %s:%d: %s", \
+              __FILE__, __LINE__, (msg)); \
+    } while (0)
+#else
+  #define UDERR(u, m) \
+    do { \
+      (u)->error = 1; \
+    } while (0)
+#endif /* !LOGERR */
+
+#define UD_RETURN_ON_ERROR(u) \
+  do { \
+    if ((u)->error != 0) { \
+      return (u)->error; \
+    } \
+  } while (0)
+
+#define UD_RETURN_WITH_ERROR(u, m) \
+  do { \
+    UDERR(u, m); \
+    return (u)->error; \
+  } while (0)
+
+#ifndef __UD_STANDALONE__
+# define UD_NON_STANDALONE(x) x
+#else
+# define UD_NON_STANDALONE(x)
+#endif
+
+/* printf formatting int64 specifier */
+#ifdef FMT64
+# undef FMT64
+#endif
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+# define FMT64 "I64"
+#else
+# if defined(__APPLE__)
+#  define FMT64 "ll"
+# elif defined(__amd64__) || defined(__x86_64__)
+#  define FMT64 "l"
+# else 
+#  define FMT64 "ll"
+# endif /* !x64 */
+#endif
+
+#endif /* _UDINT_H_ */

libudis86/udis86.c

+/* udis86 - libudis86/udis86.c
+ *
+ * Copyright (c) 2002-2013 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+
+#include "udint.h"
+#include "extern.h"
+#include "decode.h"
+
+#if !defined(__UD_STANDALONE__)
+# if HAVE_STRING_H
+#  include <string.h>
+# endif
+#endif /* !__UD_STANDALONE__ */
+
+static void ud_inp_init(struct ud *u);
+
+/* =============================================================================
+ * ud_init
+ *    Initializes ud_t object.
+ * =============================================================================
+ */
+extern void 
+ud_init(struct ud* u)
+{
+  memset((void*)u, 0, sizeof(struct ud));
+  ud_set_mode(u, 16);
+  u->mnemonic = UD_Iinvalid;
+  ud_set_pc(u, 0);
+#ifndef __UD_STANDALONE__
+  ud_set_input_file(u, stdin);
+#endif /* __UD_STANDALONE__ */
+
+  ud_set_asm_buffer(u, u->asm_buf_int, sizeof(u->asm_buf_int));
+}
+
+
+/* =============================================================================
+ * ud_disassemble
+ *    Disassembles one instruction and returns the number of 
+ *    bytes disassembled. A zero means end of disassembly.
+ * =============================================================================
+ */
+extern unsigned int
+ud_disassemble(struct ud* u)
+{
+  int len;
+  if (u->inp_end) {
+    return 0;
+  }
+  if ((len = ud_decode(u)) > 0) {
+    if (u->translator != NULL) {
+      u->asm_buf[0] = '\0';
+      u->translator(u);
+    }
+  }
+  return len;
+}
+
+
+/* =============================================================================
+ * ud_set_mode() - Set Disassemly Mode.
+ * =============================================================================
+ */
+extern void 
+ud_set_mode(struct ud* u, uint8_t m)
+{
+  switch(m) {
+  case 16:
+  case 32:
+  case 64: u->dis_mode = m ; return;
+  default: u->dis_mode = 16; return;
+  }
+}
+
+/* =============================================================================
+ * ud_set_vendor() - Set vendor.
+ * =============================================================================
+ */
+extern void 
+ud_set_vendor(struct ud* u, unsigned v)
+{
+  switch(v) {
+  case UD_VENDOR_INTEL:
+    u->vendor = v;
+    break;
+  case UD_VENDOR_ANY:
+    u->vendor = v;
+    break;
+  default:
+    u->vendor = UD_VENDOR_AMD;
+  }
+}
+
+/* =============================================================================
+ * ud_set_pc() - Sets code origin. 
+ * =============================================================================
+ */
+extern void 
+ud_set_pc(struct ud* u, uint64_t o)
+{
+  u->pc = o;
+}
+
+/* =============================================================================
+ * ud_set_syntax() - Sets the output syntax.
+ * =============================================================================
+ */
+extern void 
+ud_set_syntax(struct ud* u, void (*t)(struct ud*))
+{
+  u->translator = t;
+}
+
+/* =============================================================================
+ * ud_insn() - returns the disassembled instruction
+ * =============================================================================
+ */
+const char* 
+ud_insn_asm(const struct ud* u) 
+{
+  return u->asm_buf;
+}
+
+/* =============================================================================
+ * ud_insn_offset() - Returns the offset.
+ * =============================================================================
+ */
+uint64_t
+ud_insn_off(const struct ud* u) 
+{
+  return u->insn_offset;
+}
+
+
+/* =============================================================================
+ * ud_insn_hex() - Returns hex form of disassembled instruction.
+ * =============================================================================
+ */
+const char* 
+ud_insn_hex(struct ud* u) 
+{
+  u->insn_hexcode[0] = 0;
+  if (!u->error) {
+    unsigned int i;
+    const unsigned char *src_ptr = ud_insn_ptr(u);
+    char* src_hex;
+    src_hex = (char*) u->insn_hexcode;
+    /* for each byte used to decode instruction */
+    for (i = 0; i < ud_insn_len(u) && i < sizeof(u->insn_hexcode) / 2;
+         ++i, ++src_ptr) {
+      sprintf(src_hex, "%02x", *src_ptr & 0xFF);
+      src_hex += 2;
+    }
+  }
+  return u->insn_hexcode;
+}
+
+
+/* =============================================================================
+ * ud_insn_ptr
+ *    Returns a pointer to buffer containing the bytes that were
+ *    disassembled.
+ * =============================================================================
+ */
+extern const uint8_t* 
+ud_insn_ptr(const struct ud* u) 
+{
+  return (u->inp_buf == NULL) ? 
+            u->inp_sess : u->inp_buf + (u->inp_buf_index - u->inp_ctr);
+}
+
+
+/* =============================================================================
+ * ud_insn_len
+ *    Returns the count of bytes disassembled.
+ * =============================================================================
+ */
+extern unsigned int 
+ud_insn_len(const struct ud* u) 
+{
+  return u->inp_ctr;
+}
+
+
+/* =============================================================================
+ * ud_insn_get_opr
+ *    Return the operand struct representing the nth operand of
+ *    the currently disassembled instruction. Returns NULL if
+ *    there's no such operand.
+ * =============================================================================
+ */
+const struct ud_operand*
+ud_insn_opr(const struct ud *u, unsigned int n)
+{
+  if (n > 2 || u->operand[n].type == UD_NONE) {
+    return NULL; 
+  } else {
+    return &u->operand[n];
+  }
+}
+
+
+/* =============================================================================
+ * ud_opr_is_sreg
+ *    Returns non-zero if the given operand is of a segment register type.
+ * =============================================================================
+ */
+int
+ud_opr_is_sreg(const struct ud_operand *opr)
+{
+  return opr->type == UD_OP_REG && 
+         opr->base >= UD_R_ES   &&
+         opr->base <= UD_R_GS;
+}
+
+
+/* =============================================================================
+ * ud_opr_is_sreg
+ *    Returns non-zero if the given operand is of a general purpose
+ *    register type.
+ * =============================================================================
+ */
+int
+ud_opr_is_gpr(const struct ud_operand *opr)
+{
+  return opr->type == UD_OP_REG && 
+         opr->base >= UD_R_AL   &&
+         opr->base <= UD_R_R15;
+}
+
+
+/* =============================================================================
+ * ud_set_user_opaque_data
+ * ud_get_user_opaque_data
+ *    Get/set user opaqute data pointer
+ * =============================================================================
+ */
+void
+ud_set_user_opaque_data(struct ud * u, void* opaque)
+{
+  u->user_opaque_data = opaque;
+}
+
+void*
+ud_get_user_opaque_data(const struct ud *u)
+{
+  return u->user_opaque_data;
+}
+
+
+/* =============================================================================
+ * ud_set_asm_buffer
+ *    Allow the user to set an assembler output buffer. If `buf` is NULL,
+ *    we switch back to the internal buffer.
+ * =============================================================================
+ */
+void
+ud_set_asm_buffer(struct ud *u, char *buf, size_t size)
+{
+  if (buf == NULL) {
+    ud_set_asm_buffer(u, u->asm_buf_int, sizeof(u->asm_buf_int));
+  } else {
+    u->asm_buf = buf;
+    u->asm_buf_size = size;
+  }
+}
+
+
+/* =============================================================================
+ * ud_set_sym_resolver
+ *    Set symbol resolver for relative targets used in the translation
+ *    phase.
+ *
+ *    The resolver is a function that takes a uint64_t address and returns a
+ *    symbolic name for the that address. The function also takes a second
+ *    argument pointing to an integer that the client can optionally set to a
+ *    non-zero value for offsetted targets. (symbol+offset) The function may
+ *    also return NULL, in which case the translator only prints the target
+ *    address.
+ *
+ *    The function pointer maybe NULL which resets symbol resolution.
+ * =============================================================================
+ */
+void
+ud_set_sym_resolver(struct ud *u, const char* (*resolver)(struct ud*, 
+                                                          uint64_t addr,
+                                                          int64_t *offset))
+{
+  u->sym_resolver = resolver;
+}
+
+
+/* =============================================================================
+ * ud_insn_mnemonic
+ *    Return the current instruction mnemonic.
+ * =============================================================================
+ */
+enum ud_mnemonic_code
+ud_insn_mnemonic(const struct ud *u)
+{
+  return u->mnemonic;
+}
+
+
+/* =============================================================================
+ * ud_lookup_mnemonic
+ *    Looks up mnemonic code in the mnemonic string table.
+ *    Returns NULL if the mnemonic code is invalid.
+ * =============================================================================
+ */
+const char*
+ud_lookup_mnemonic(enum ud_mnemonic_code c)
+{
+  if (c < UD_MAX_MNEMONIC_CODE) {
+    return ud_mnemonics_str[c];
+  } else {
+    return NULL;
+  }
+}
+
+
+/* 
+ * ud_inp_init
+ *    Initializes the input system.
+ */
+static void
+ud_inp_init(struct ud *u)
+{
+  u->inp_hook      = NULL;
+  u->inp_buf       = NULL;
+  u->inp_buf_size  = 0;
+  u->inp_buf_index = 0;
+  u->inp_curr      = 0;
+  u->inp_ctr       = 0;
+  u->inp_end       = 0;
+  UD_NON_STANDALONE(u->inp_file = NULL);
+}
+
+
+/* =============================================================================
+ * ud_inp_set_hook
+ *    Sets input hook.
+ * =============================================================================
+ */
+void 
+ud_set_input_hook(register struct ud* u, int (*hook)(struct ud*))
+{
+  ud_inp_init(u);
+  u->inp_hook = hook;
+}
+
+/* =============================================================================
+ * ud_inp_set_buffer
+ *    Set buffer as input.
+ * =============================================================================
+ */
+void 
+ud_set_input_buffer(register struct ud* u, const uint8_t* buf, size_t len)
+{
+  ud_inp_init(u);
+  u->inp_buf = buf;
+  u->inp_buf_size = len;
+  u->inp_buf_index = 0;
+}
+
+
+#ifndef __UD_STANDALONE__
+/* =============================================================================
+ * ud_input_set_file
+ *    Set FILE as input.
+ * =============================================================================
+ */
+static int 
+inp_file_hook(struct ud* u)
+{
+  return fgetc(u->inp_file);
+}
+
+void 
+ud_set_input_file(register struct ud* u, FILE* f)
+{
+  ud_inp_init(u);
+  u->inp_hook = inp_file_hook;
+  u->inp_file = f;
+}
+#endif /* __UD_STANDALONE__ */
+
+
+/* =============================================================================
+ * ud_input_skip
+ *    Skip n input bytes.
+ * ============================================================================
+ */
+void 
+ud_input_skip(struct ud* u, size_t n)
+{
+  if (u->inp_end) {
+    return;
+  }
+  if (u->inp_buf == NULL) {
+    while (n--) {
+      int c = u->inp_hook(u);
+      if (c == UD_EOI) {
+        goto eoi;
+      }
+    }
+    return;
+  } else {
+    if (n > u->inp_buf_size ||
+        u->inp_buf_index > u->inp_buf_size - n) {
+      u->inp_buf_index = u->inp_buf_size; 
+      goto eoi;
+    }
+    u->inp_buf_index += n; 
+    return;
+  }
+eoi:
+  u->inp_end = 1;
+  UDERR(u, "cannot skip, eoi received\b");
+  return;
+}
+
+
+/* =============================================================================
+ * ud_input_end
+ *    Returns non-zero on end-of-input.
+ * =============================================================================
+ */
+int
+ud_input_end(const struct ud *u)
+{
+  return u->inp_end;
+}
+
+/* vim:set ts=2 sw=2 expandtab */

list.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "list.h"
+
+struct ListHead* list_create()
+{
+	return calloc(1, sizeof(struct ListHead));
+}
+
+int list_add(struct ListHead* head, void* data, size_t size)
+{
+	assert(head);
+
+	struct ListElem* p = malloc(sizeof(struct ListElem) + size);
+	if(!p)
+		return -1;
+
+	p->next = NULL;
+	p->dataSize = size;
+	memcpy((char*)p + sizeof(struct ListElem), data, size);
+	p->dataStart = (char*)p + sizeof(struct ListElem);
+
+	// First elem to ever be added?
+	if(!head->end)
+	{
+		head->end = head->start = p;
+	}
+	else
+	{
+		head->end->next = p;
+		head->end = p;
+	}
+
+	return 0;
+}
+
+// todo:
+int list_free(struct ListHead* head)
+{
+	struct ListElem* p = head->start;
+
+	while(p)
+	{
+		struct ListElem* pOld = p;
+		p = p->next;
+
+		free(pOld);
+	}
+
+	free(head);
+
+	return 0;
+}

list.h

+#ifndef LIST_H
+#define LIST_H
+
+
+struct ListElem
+{
+	void* dataStart;
+	size_t dataSize;
+
+	struct ListElem* next;
+};
+
+struct ListHead
+{
+	struct ListElem* start;
+	struct ListElem* end;
+};
+
+struct ListHead* list_create();
+
+int list_add(struct ListHead* head, void* data, size_t size);
+
+int list_free(struct ListHead* head);
+
+#endif // LIST_H

main.c

+#include <stdio.h>
+#include <Windows.h>
+#include "misc.h"
+#include "hook.h"
+
+#if 0
+Check whether trampoline works correctly
+start:
+	je lbl1
+	jmp lbl1
+lbl1:
+
+---
+hook() == LOOPS_INTO_OVERWRITTEN_CODE
+start:
+	mov eax, 3
+l:
+	dec eax
+	test eax, eax
+	je l
+
+
+#endif
+
+
+static int test(int a, int b);
+static void normal(int a, int b, int c, int d, int e);
+static void normal2(int a, int b, int c, int d, int e);
+typedef void(*FUNCTYPE)(int a, int b, int c, int d, int e);
+
+static void hooked(int a, int b, int c, int d, int e);
+static FUNCTYPE original;
+
+int main(int argc, char** argv)
+{
+	int r = 0;
+
+	if((r = hook(normal2, 0, hooked, &original)) < 0)
+	{
+		printf("CAn't hook: %d\n", r);
+		return 1;
+	}
+
+
+	printf("---\nDisass. trampoline/original\n");
+	disassemble_func(original, 10);
+	original(3, 1, 1, 1, 1);
+	//original(5, 1, 1, 1, 1);	
+
+	VirtualFree(original, 0, MEM_RELEASE);
+
+	(void)getc(stdin);
+}
+
+static int test(int a, int b)
+{
+	if(a == 0)
+		return 5;
+	else if(a == 1)
+		return b;
+	return a;
+}
+
+static void normal(int a, int b, int c, int d, int e)
+{
+	printf("Result: %d\n", a*b*c*d*e);
+}
+
+static void normal2(int a, int b, int c, int d, int e)
+{
+	if(a == 3)
+		return;
+	printf("Result: %d\n", a*b*c*d*e);
+}
+
+static void hooked(int a, int b, int c, int d, int e)
+{
+	original(1, b, c, d, e);
+}

misc.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "udis86.h"
+#include "misc.h"
+
+void disassemble_func(void* function, size_t numberOfInstr)
+{
+	unsigned char* p = function;
+	ud_t ud;
+
+	ud_init(&ud);
+	ud_set_input_buffer(&ud, function, (size_t)function | (0x1000 - 1)); // Can't read further than page boundary - there be dragons
+	ud_set_pc(&ud, (uint64_t)function);
+	ud_set_mode(&ud, 64);
+	ud_set_syntax(&ud, UD_SYN_INTEL);
+
+	for(size_t i = 0; i < numberOfInstr; i++)
+	{
+		size_t instrLen = 0;
+		if(!(instrLen = ud_disassemble(&ud)) || ud.error)
+			return;
+
+		p += instrLen;
+
+		printf("%p %s\n", ud_insn_off(&ud), ud_insn_asm(&ud));
+
+		// ugly, ugly hack todo: make it work
+		if(strcmp(ud_insn_asm(&ud), "jmp qword [rip]") == 0)
+			p += 8;
+	}
+}

misc.h

+#ifndef MISC_H
+#define MISC_H
+
+void disassemble_func(void* func, size_t numberOfInstr);
+
+#endif MISC_H

udis86.h

+/* udis86 - udis86.h
+ *
+ * Copyright (c) 2002-2009 Vivek Thampi
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright notice, 
+ *       this list of conditions and the following disclaimer.
+ *     * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef UDIS86_H
+#define UDIS86_H
+
+#include "libudis86/types.h"
+#include "libudis86/extern.h"
+#include "libudis86/itab.h"
+
+#endif

x64/Debug/x64Hook.log

+Der Buildvorgang wurde am 19.09.2015 20:49:48 gestartet.
+     1>Projekt "U:\small shit\x64Hook\x64Hook\x64Hook.vcxproj" auf Knoten "2", Build Ziel(e).
+     1>ClCompile:
+         D:\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\CL.exe /c /Zi /nologo /W3 /WX- /Od /D WIN32 /D _DEBUG /D _CONSOLE /D _LIB /D _UNICODE /D UNICODE /Gm /EHsc /RTC1 /MDd /GS /fp:precise /Zc:wchar_t /Zc:forScope /Fo"x64\Debug\\" /Fd"x64\Debug\vc120.pdb" /Gd /TC /errorReport:prompt hook.c libudis86\decode.c libudis86\itab.c "libudis86\syn-att.c" "libudis86\syn-intel.c" libudis86\syn.c libudis86\udis86.c list.c main.c misc.c
+         misc.c
+     1>misc.c(28): warning C4013: 'strcmp' undefiniert; Annahme: extern mit Rückgabetyp int
+         main.c
+         list.c
+     1>list.c(21): warning C4013: 'memcpy' undefiniert; Annahme: extern mit Rückgabetyp int
+         udis86.c
+     1>libudis86\udis86.c(47): warning C4013: 'memset' undefiniert; Annahme: extern mit Rückgabetyp int
+     1>libudis86\udis86.c(173): warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+                 D:\Microsoft Visual Studio 12.0\VC\include\stdio.h(356): Siehe Deklaration von 'sprintf'
+     1>libudis86\udis86.c(203): warning C4267: 'return': Konvertierung von 'size_t' nach 'unsigned int', Datenverlust möglich
+         syn.c
+     1>libudis86\syn.c(114): warning C4267: '=': Konvertierung von 'size_t' nach 'int', Datenverlust möglich
+     1>libudis86\syn.c(115): warning C4996: 'vsnprintf': This function or variable may be unsafe. Consider using vsnprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+                 D:\Microsoft Visual Studio 12.0\VC\include\stdio.h(337): Siehe Deklaration von 'vsnprintf'
+         syn-intel.c
+         syn-att.c
+         itab.c
+         decode.c
+     1>libudis86\decode.c(615): warning C4267: 'Funktion': Konvertierung von 'size_t' nach 'unsigned int', Datenverlust möglich
+     1>libudis86\decode.c(1107): warning C4267: 'return': Konvertierung von 'size_t' nach 'unsigned int', Datenverlust möglich
+         hook.c
+         Code wird generiert...
+     1>u:\small shit\x64hook\x64hook\libudis86\decode.c(211): warning C4700: Die nicht initialisierte lokale Variable "curr" wurde verwendet.
+       Link:
+         D:\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\link.exe /ERRORREPORT:PROMPT /OUT:"U:\small shit\x64Hook\x64\Debug\x64Hook.exe" /INCREMENTAL /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"U:\small shit\x64Hook\x64\Debug\x64Hook.pdb" /SUBSYSTEM:CONSOLE /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"U:\small shit\x64Hook\x64\Debug\x64Hook.lib" /MACHINE:X64 x64\Debug\hook.obj
+         x64\Debug\decode.obj
+         x64\Debug\itab.obj
+         "x64\Debug\syn-att.obj"
+         "x64\Debug\syn-intel.obj"
+         x64\Debug\syn.obj
+         x64\Debug\udis86.obj
+         x64\Debug\list.obj
+         x64\Debug\main.obj
+         x64\Debug\misc.obj
+         x64Hook.vcxproj -> U:\small shit\x64Hook\x64\Debug\x64Hook.exe
+     1>Die Erstellung des Projekts "U:\small shit\x64Hook\x64Hook\x64Hook.vcxproj" ist abgeschlossen, Build Ziel(e).
+
+Build erfolgreich.
+
+Verstrichene Zeit 00:00:02.88

x64/Debug/x64Hook.tlog/x64Hook.lastbuildstate

+#TargetFrameworkVersion=v4.0:PlatformToolSet=v120:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit
+Debug|x64|U:\small shit\x64Hook\|

x64/Release/x64Hook.log

+Der Buildvorgang wurde am 19.09.2015 21:52:12 gestartet.
+     1>Projekt "U:\small shit\x64Hook\x64Hook\x64Hook.vcxproj" auf Knoten "2", Build Ziel(e).
+     1>ClCompile:
+         D:\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\CL.exe /c /Zi /nologo /W3 /WX- /O2 /Oi /GL /D WIN32 /D NDEBUG /D _CONSOLE /D _LIB /D _UNICODE /D UNICODE /Gm- /EHsc /MD /GS /Gy /fp:precise /Zc:wchar_t /Zc:forScope /Fo"x64\Release\\" /Fd"x64\Release\vc120.pdb" /Gd /TC /errorReport:prompt hook.c
+         hook.c
+     1>hook.c(149): warning C4047: 'Initialisierung': Anzahl der Dereferenzierungen bei 'void *' und 'uint64_t' unterschiedlich
+     1>hook.c(211): warning C4047: 'Funktion': Anzahl der Dereferenzierungen bei 'const char *' und 'uint64_t' unterschiedlich
+     1>hook.c(211): warning C4024: 'printf': Unterschiedliche Typen für formalen und übergebenen Parameter 1
+       Link:
+         D:\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\link.exe /ERRORREPORT:PROMPT /OUT:"U:\small shit\x64Hook\x64\Release\x64Hook.exe" /INCREMENTAL:NO /NOLOGO kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed /DEBUG /PDB:"U:\small shit\x64Hook\x64\Release\x64Hook.pdb" /SUBSYSTEM:CONSOLE /OPT:REF /OPT:ICF /LTCG /TLBID:1 /DYNAMICBASE /NXCOMPAT /IMPLIB:"U:\small shit\x64Hook\x64\Release\x64Hook.lib" /MACHINE:X64 x64\Release\hook.obj
+         x64\Release\decode.obj
+         x64\Release\itab.obj
+         "x64\Release\syn-att.obj"
+         "x64\Release\syn-intel.obj"
+         x64\Release\syn.obj
+         x64\Release\udis86.obj
+         x64\Release\list.obj
+         x64\Release\main.obj
+         x64\Release\misc.obj
+         Code wird generiert.
+     1>u:\small shit\x64hook\x64hook\libudis86\decode.c(211): warning C4700: Die nicht initialisierte lokale Variable "curr" wurde verwendet.
+         Codegenerierung ist abgeschlossen.
+         x64Hook.vcxproj -> U:\small shit\x64Hook\x64\Release\x64Hook.exe
+     1>Die Erstellung des Projekts "U:\small shit\x64Hook\x64Hook\x64Hook.vcxproj" ist abgeschlossen, Build Ziel(e).
+
+Build erfolgreich.
+
+Verstrichene Zeit 00:00:01.49

x64/Release/x64Hook.tlog/x64Hook.lastbuildstate

+#TargetFrameworkVersion=v4.0:PlatformToolSet=v120:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit
+Release|x64|U:\small shit\x64Hook\|

x64/x64/x64Hook.log

+Der Buildvorgang wurde am 18.09.2015 21:14:40 gestartet.
+     1>Projekt "U:\small shit\x64Hook\x64Hook\x64Hook.vcxproj" auf Knoten "2", Build Ziel(e).
+     1>ClCompile:
+         D:\Microsoft Visual Studio 12.0\VC\bin\x86_amd64\CL.exe /c /Zi /nologo /Wall /WX- /Ox /D WIN32 /D _DEBUG /D _CONSOLE /D _LIB /D _UNICODE /D UNICODE /Gm /EHsc /RTC1 /MDd /GS /fp:precise /Zc:wchar_t /Zc:forScope /Fo"x64\x64\\" /Fd"x64\x64\vc120.pdb" /Gd /TC /errorReport:prompt hde64.c hook.c main.c
+     1>cl : Befehlszeile error D8016: Die Befehlszeilenoptionen /Ox und /RTC1 sind inkompatibel.
+     1>Die Erstellung des Projekts "U:\small shit\x64Hook\x64Hook\x64Hook.vcxproj" ist abgeschlossen, Build Ziel(e) -- FEHLER.
+
+Fehler beim Buildvorgang.
+
+Verstrichene Zeit 00:00:00.44

x64/x64/x64Hook.tlog/x64Hook.lastbuildstate

+#TargetFrameworkVersion=v4.0:PlatformToolSet=v120:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit
+x64|x64|U:\small shit\x64Hook\|

x64Hook.vcxproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="x64|Win32">
+      <Configuration>x64</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="x64|x64">
+      <Configuration>x64</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B5F6B473-F0C6-4EC5-A3AC-888BC60D5369}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>x64Hook</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='x64|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='x64|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='x64|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='x64|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>EnableAllWarnings</WarningLevel>
+      <Optimization>Full</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>CompileAsC</CompileAs>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="hook.c" />
+    <ClCompile Include="libudis86\decode.c" />
+    <ClCompile Include="libudis86\itab.c" />
+    <ClCompile Include="libudis86\syn-att.c" />
+    <ClCompile Include="libudis86\syn-intel.c" />
+    <ClCompile Include="libudis86\syn.c" />
+    <ClCompile Include="libudis86\udis86.c" />
+    <ClCompile Include="list.c" />
+    <ClCompile Include="main.c" />
+    <ClCompile Include="misc.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="hook.h" />
+    <ClInclude Include="libudis86\decode.h" />
+    <ClInclude Include="libudis86\extern.h" />
+    <ClInclude Include="libudis86\itab.h" />
+    <ClInclude Include="libudis86\syn.h" />
+    <ClInclude Include="libudis86\types.h" />
+    <ClInclude Include="libudis86\udint.h" />
+    <ClInclude Include="list.h" />
+    <ClInclude Include="misc.h" />
+    <ClInclude Include="udis86.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

x64Hook.vcxproj.filters

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Quelldateien">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Headerdateien">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Ressourcendateien">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Headerdateien\udis86">
+      <UniqueIdentifier>{b48aae6c-c93a-4310-aaf0-ff9553bdeff0}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Quelldateien\udis86">
+      <UniqueIdentifier>{bed1caaf-c880-4a1d-b621-d4d2a098f7fc}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="main.c">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="hook.c">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="libudis86\decode.c">
+      <Filter>Quelldateien\udis86</Filter>
+    </ClCompile>
+    <ClCompile Include="libudis86\itab.c">
+      <Filter>Quelldateien\udis86</Filter>
+    </ClCompile>
+    <ClCompile Include="libudis86\syn.c">
+      <Filter>Quelldateien\udis86</Filter>
+    </ClCompile>
+    <ClCompile Include="libudis86\syn-att.c">
+      <Filter>Quelldateien\udis86</Filter>
+    </ClCompile>
+    <ClCompile Include="libudis86\syn-intel.c">
+      <Filter>Quelldateien\udis86</Filter>
+    </ClCompile>
+    <ClCompile Include="libudis86\udis86.c">
+      <Filter>Quelldateien\udis86</Filter>
+    </ClCompile>
+    <ClCompile Include="misc.c">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="list.c">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="hook.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="libudis86\decode.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="libudis86\extern.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="libudis86\itab.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="libudis86\syn.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="libudis86\types.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="libudis86\udint.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="udis86.h">
+      <Filter>Headerdateien\udis86</Filter>
+    </ClInclude>
+    <ClInclude Include="misc.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="list.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>