Add Glave XGL tracer and replayer tools
diff --git a/tools/glave/CMakeLists.txt b/tools/glave/CMakeLists.txt
new file mode 100644
index 0000000..8749422
--- /dev/null
+++ b/tools/glave/CMakeLists.txt
@@ -0,0 +1,72 @@
+PROJECT(gl5debugger)
+cmake_minimum_required(VERSION 2.8)
+
+set(SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
+
+#set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${SRC_DIR}/cmake/Modules/")
+#set(CMAKE_EXTERNAL_PATH "${SRC_DIR}/../../external")
+
+if (WIN32)
+ # TODO: s/CMAKE_PREFIX_PATH/CMAKE_EXTERNAL_WINDOWS_PATH/g
+# set(CMAKE_PREFIX_PATH "${CMAKE_EXTERNAL_PATH}/windows")
+ set(WIN32_PTHREADS_PATH "${SRC_DIR}/thirdparty/pthreads.2")
+ set(WIN32_PTHREADS_INCLUDE_PATH "${WIN32_PTHREADS_PATH}/include")
+endif()
+
+find_package(PythonLibs REQUIRED)
+find_package(PythonInterp REQUIRED)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+set(GEN_API "xgl")
+else()
+set(GEN_API "mantle")
+endif()
+
+set(CODE_GEN_DIR "glv_extensions/glave_${GEN_API}_gen")
+
+execute_process(COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/code_gen.py --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/src/${CODE_GEN_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src/thirdparty/${GEN_API}/inc/${GEN_API}.h)
+
+
+message("")
+message("cmake options:")
+message(" -DCMAKE_BUILD_TYPE='${CMAKE_BUILD_TYPE}': Build debug or release. (Debug|Release)")
+message(" -DCMAKE_VERBOSE='${CMAKE_VERBOSE}': Spew cmake project options. (On|Off)")
+message(" -DBUILD_X64='${BUILD_X64}': Build 32 or 64-bit. (On|Off)")
+message("")
+
+#
+# Components to build
+#
+
+add_subdirectory(src/thirdparty/getopt)
+add_subdirectory(src/glvcommon)
+add_subdirectory(src/glvinception)
+add_subdirectory(src/glvtrace)
+add_subdirectory(src/glvreplay)
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+add_subdirectory(src/thirdparty/mhook/mhook-lib)
+add_subdirectory(src/thirdparty/mhook/disasm-lib)
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+
+# use macro from stackoverflow (link below) to get all the extensions that are on the current system
+# http://stackoverflow.com/questions/7787823/cmake-how-to-get-the-name-of-all-subdirectories-of-a-directory
+MACRO(SUBDIRLIST result curdir)
+ FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
+ SET(dirlist "")
+ FOREACH(child ${children})
+ IF(IS_DIRECTORY ${curdir}/${child})
+ LIST(APPEND dirlist ${child})
+ ENDIF()
+ ENDFOREACH()
+ SET(${result} ${dirlist})
+ENDMACRO()
+
+# now generate the list and add each of the subdirectories
+SUBDIRLIST(SUBDIRS ${SRC_DIR}/glv_extensions)
+message("Adding extensions: '${SUBDIRS}'")
+FOREACH(subdir ${SUBDIRS})
+ add_subdirectory(${SRC_DIR}/glv_extensions/${subdir})
+ENDFOREACH()
+
+
+
diff --git a/tools/glave/README.md b/tools/glave/README.md
new file mode 100644
index 0000000..7d8e470
--- /dev/null
+++ b/tools/glave/README.md
@@ -0,0 +1,70 @@
+Glave (aka gl5_debugger)
+============
+
+Working towards a tracer / debugger of OpenGL5 applications.
+
+###Obtain code###
+```
+git clone https://github.com/KhronosGroup/GL-Next.git
+```
+
+###External dependencies###
+* XGL
+ XGL headers retrieved in place (tools/glave/../../include) by Cmake
+ XGL library retrieved in place (tools/glave/../../<build_dir>/loader by Cmake
+* Python 3.4 (Ubuntu package python3.4-dev)
+* Qt 5 (Ubuntu package qt5-default) (only needed for glave debugger)
+* Mantle (headers and library from AMD's Mantle SDK which is under NDA)
+ * Place in src/thirdparty/mantle ( ONLY needed if using Mantle API)
+
+###Building on Windows###
+```
+cd tools/glave
+mkdir Win64
+cd Win64
+cmake -G "Visual Studio 10 2010 Win64" ..
+// then open the solution file with Visual Studio 2010
+```
+
+###Building on Linux (make)###
+```
+cd tools/glave
+mkdir glv_build
+cd glv_build
+cmake -DCMAKE_BUILD_TYPE=Debug ..
+make
+```
+
+###Building on Linux (QtCreator)###
+```
+open tools/glave/CMakeLists.txt with QtCreater
+Cmake options: -DCMAKE_BUILD_TYPE=Debug -DBUILD_X64=On
+Change build directory from the suggested 'gl5-debugger' to 'glv_build' (if you want to maintain consistency with the Windows build)
+```
+
+###Running tracer###
+```
+The Glave tracer program launches the app/game you desire and then traces it.
+cd glv_build
+./glvtrace64 <options>
+Example to trace the spinning cube demo from sample implementation
+export LIBXGL_DRIVERS_PATH=/home/jon/dbuild/icd/intel
+export LD_LIBRARY_PATH=/home/jon/dbuild/loader
+./glvtrace64 -p /home/jon/xgl/dbuild/demos/cube -l0 /home/jon/glave/glv_build/libglvtrace_xgl64.so -o glvtrace_cube.glv -w /home/jon/xgl/dbuild/demos
+Trace file is in "glvtrace_cube.glv".
+
+Rather than giving command line options, can instead put tracer options in a
+settings file: "glvtrace_settings.txt".
+```
+
+###Running replayer###
+```
+The Glave replayer takes a trace file and will launch an XGL session based
+on trace file.
+cd glv_build
+./glvreplay64 <options> trace_filename
+Example to replay trace file captured above
+export LIBXGL_DRIVERS_PATH=/home/jon/dbuild/icd/intel
+export LD_LIBRARY_PATH=/home/jon/dbuild/loader
+./glvreplay64 glvtrace_cube.glv
+```
\ No newline at end of file
diff --git a/tools/glave/scripts/code_gen.py b/tools/glave/scripts/code_gen.py
new file mode 100644
index 0000000..6fa0c97
--- /dev/null
+++ b/tools/glave/scripts/code_gen.py
@@ -0,0 +1,827 @@
+import argparse
+import os
+import sys
+
+# code_gen.py overview
+# This script generates code based on input headers
+# Initially it's intended to support Mantle and XGL headers and
+# generate wrappers functions that can be used to display
+# structs in a human-readable txt format, as well as utility functions
+# to print enum values as strings
+
+
+def handle_args():
+ parser = argparse.ArgumentParser(description='Perform analysis of vogl trace.')
+ parser.add_argument('input_file', help='The input header file from which code will be generated.')
+ parser.add_argument('--rel_out_dir', required=False, default='glave_gen', help='Path relative to exec path to write output files. Will be created if needed.')
+ parser.add_argument('--abs_out_dir', required=False, default=None, help='Absolute path to write output files. Will be created if needed.')
+ parser.add_argument('--gen_graphviz', required=False, action='store_true', default=False, help='Enable generation of graphviz dot file.')
+ #parser.add_argument('--test', action='store_true', default=False, help='Run simple test.')
+ return parser.parse_args()
+
+# TODO : Ideally these data structs would be opaque to user and could be wrapped
+# in their own class(es) to make them friendly for data look-up
+# Dicts for Data storage
+# enum_val_dict[value_name] = dict keys are the string enum value names for all enums
+# |-------->['type'] = the type of enum class into which the value falls
+# |-------->['val'] = the value assigned to this particular value_name
+# '-------->['unique'] = bool designating if this enum 'val' is unique within this enum 'type'
+enum_val_dict = {}
+# enum_type_dict['type'] = the type or class of of enum
+# '----->['val_name1', 'val_name2'...] = each type references a list of val_names within this type
+enum_type_dict = {}
+# struct_dict['struct_basename'] = the base (non-typedef'd) name of the struct
+# |->[<member_num>] = members are stored via their integer placement in the struct
+# | |->['name'] = string name of this struct member
+# ... |->['full_type'] = complete type qualifier for this member
+# |->['type'] = base type for this member
+# |->['ptr'] = bool indicating if this member is ptr
+# |->['const'] = bool indicating if this member is const
+# |->['struct'] = bool indicating if this member is a struct type
+# |->['array'] = bool indicating if this member is an array
+# '->['array_size'] = int indicating size of array members (0 by default)
+struct_dict = {}
+# typedef_fwd_dict stores mapping from orig_type_name -> new_type_name
+typedef_fwd_dict = {}
+# typedef_rev_dict stores mapping from new_type_name -> orig_type_name
+typedef_rev_dict = {} # store new_name -> orig_name mapping
+# types_dict['id_name'] = identifier name will map to it's type
+# '---->'type' = currently either 'struct' or 'enum'
+types_dict = {} # store orig_name -> type mapping
+
+
+# Class that parses header file and generates data structures that can
+# Then be used for other tasks
+class HeaderFileParser:
+ def __init__(self, header_file=None):
+ self.header_file = header_file
+ # store header data in various formats, see above for more info
+ self.enum_val_dict = {}
+ self.enum_type_dict = {}
+ self.struct_dict = {}
+ self.typedef_fwd_dict = {}
+ self.typedef_rev_dict = {}
+ self.types_dict = {}
+
+ def setHeaderFile(self, header_file):
+ self.header_file = header_file
+
+ def get_enum_val_dict(self):
+ return self.enum_val_dict
+
+ def get_enum_type_dict(self):
+ return self.enum_type_dict
+
+ def get_struct_dict(self):
+ return self.struct_dict
+
+ def get_typedef_fwd_dict(self):
+ return self.typedef_fwd_dict
+
+ def get_typedef_rev_dict(self):
+ return self.typedef_rev_dict
+
+ def get_types_dict(self):
+ return self.types_dict
+
+ # Parse header file into data structures
+ def parse(self):
+ # parse through the file, identifying different sections
+ parse_enum = False
+ parse_struct = False
+ member_num = 0
+ # TODO : Comment parsing is very fragile but handles 2 known files
+ block_comment = False
+ with open(self.header_file) as f:
+ for line in f:
+ if block_comment:
+ if '*/' in line:
+ block_comment = False
+ continue
+ if '/*' in line:
+ block_comment = True
+ elif 0 == len(line.split()):
+ #print("Skipping empty line")
+ continue
+ elif line.split()[0].strip().startswith("//"):
+ #print("Skipping commentted line %s" % line)
+ continue
+ elif 'typedef enum' in line:
+ (ty_txt, en_txt, base_type) = line.strip().split(None, 2)
+ #print("Found ENUM type %s" % base_type)
+ parse_enum = True
+ self.types_dict[base_type] = 'enum'
+ elif 'typedef struct' in line:
+ (ty_txt, st_txt, base_type) = line.strip().split(None, 2)
+ #print("Found STRUCT type: %s" % base_type)
+ parse_struct = True
+ self.types_dict[base_type] = 'struct'
+ elif '}' in line and (parse_enum or parse_struct):
+ if len(line.split()) > 1: # deals with embedded union in one struct
+ parse_enum = False
+ parse_struct = False
+ member_num = 0
+ # TODO : Can pull target of typedef here for remapping
+ (cur_char, targ_type) = line.strip().split(None, 1)
+ self.typedef_fwd_dict[base_type] = targ_type.strip(';')
+ self.typedef_rev_dict[targ_type.strip(';')] = base_type
+ elif parse_enum:
+ if '=' in line:
+ self._add_enum(line, base_type)
+ elif parse_struct:
+ if ';' in line:
+ self._add_struct(line, base_type, member_num)
+ member_num = member_num + 1
+ #elif '(' in line:
+ #print("Function: %s" % line)
+
+ # populate enum dicts based on enum lines
+ def _add_enum(self, line_txt, enum_type):
+ #print("Parsing enum line %s" % line_txt)
+ (enum_name, eq_char, enum_val) = line_txt.split(None, 2)
+ if '=' != eq_char:
+ print("ERROR: Couldn't parse enum line: %s" % line_txt)
+ self.enum_val_dict[enum_name] = {}
+ self.enum_val_dict[enum_name]['type'] = enum_type
+ # strip comma and comment, then extra split in case of no comma w/ comments
+ enum_val = enum_val.strip().split(',', 1)[0]
+ self.enum_val_dict[enum_name]['val'] = enum_val.split()[0]
+ # TODO : Make this more robust, to verify if enum value is unique
+ # Currently just try to cast to int which works ok but missed -(HEX) values
+ try:
+ #print("ENUM val:", self.enum_val_dict[enum_name]['val'])
+ int(self.enum_val_dict[enum_name]['val'], 0)
+ self.enum_val_dict[enum_name]['unique'] = True
+ #print("ENUM has num value")
+ except ValueError:
+ self.enum_val_dict[enum_name]['unique'] = False
+ #print("ENUM is not a number value")
+ # Update enum_type_dict as well
+ if not enum_type in self.enum_type_dict:
+ self.enum_type_dict[enum_type] = []
+ self.enum_type_dict[enum_type].append(enum_name)
+
+ # populate struct dicts based on struct lines
+ # TODO : Handle ":" bitfield, "**" ptr->ptr and "const type*const*"
+ def _add_struct(self, line_txt, struct_type, num):
+ #print("Parsing struct line %s" % line_txt)
+ if not struct_type in self.struct_dict:
+ self.struct_dict[struct_type] = {}
+ members = line_txt.strip().split(';', 1)[0] # first strip semicolon & comments
+ # TODO : Handle bitfields more correctly
+ members = members.strip().split(':', 1)[0] # strip bitfield element
+ (member_type, member_name) = members.rsplit(None, 1)
+ self.struct_dict[struct_type][num] = {}
+ self.struct_dict[struct_type][num]['full_type'] = member_type
+ if '*' in member_type:
+ self.struct_dict[struct_type][num]['ptr'] = True
+ member_type = member_type.strip('*')
+ else:
+ self.struct_dict[struct_type][num]['ptr'] = False
+ if 'const' in member_type:
+ self.struct_dict[struct_type][num]['const'] = True
+ member_type = member_type.strip('const').strip()
+ else:
+ self.struct_dict[struct_type][num]['const'] = False
+ if is_type(member_type, 'struct'):
+ self.struct_dict[struct_type][num]['struct'] = True
+ else:
+ self.struct_dict[struct_type][num]['struct'] = False
+ self.struct_dict[struct_type][num]['type'] = member_type
+ if '[' in member_name:
+ (member_name, array_size) = member_name.split('[', 1)
+ self.struct_dict[struct_type][num]['array'] = True
+ self.struct_dict[struct_type][num]['array_size'] = array_size.strip(']')
+ else:
+ self.struct_dict[struct_type][num]['array'] = False
+ self.struct_dict[struct_type][num]['array_size'] = 0
+ self.struct_dict[struct_type][num]['name'] = member_name
+
+# check if given identifier if of specified type_to_check
+def is_type(identifier, type_to_check):
+ #print("Checking if %s is type %s" % (identifier, type_to_check))
+ if identifier in types_dict and type_to_check == types_dict[identifier]:
+ return True
+ if identifier in typedef_rev_dict:
+ new_id = typedef_rev_dict[identifier]
+ if new_id in types_dict and type_to_check == types_dict[new_id]:
+ return True
+ return False
+
+def recreate_structs():
+ for struct_name in struct_dict:
+ sys.stdout.write("typedef struct %s\n{\n" % struct_name)
+ for mem_num in sorted(struct_dict[struct_name]):
+ sys.stdout.write(" ")
+ if struct_dict[struct_name][mem_num]['const']:
+ sys.stdout.write("const ")
+ #if struct_dict[struct_name][mem_num]['struct']:
+ # sys.stdout.write("struct ")
+ sys.stdout.write (struct_dict[struct_name][mem_num]['type'])
+ if struct_dict[struct_name][mem_num]['ptr']:
+ sys.stdout.write("*")
+ sys.stdout.write(" ")
+ sys.stdout.write(struct_dict[struct_name][mem_num]['name'])
+ if struct_dict[struct_name][mem_num]['array']:
+ sys.stdout.write("[")
+ sys.stdout.write(struct_dict[struct_name][mem_num]['array_size'])
+ sys.stdout.write("]")
+ sys.stdout.write(";\n")
+ sys.stdout.write("} ")
+ sys.stdout.write(typedef_fwd_dict[struct_name])
+ sys.stdout.write(";\n\n")
+
+# class for writing common file elements
+# Here's how this class lays out a file:
+# COPYRIGHT
+# HEADER
+# BODY
+# FOOTER
+#
+# For each of these sections, there's a "set*" function
+# The class as a whole has a generate function which will write each section in order
+class CommonFileGen:
+ def __init__(self, filename=None, copyright_txt="", header_txt="", body_txt="", footer_txt=""):
+ self.filename = filename
+ self.contents = {'copyright': copyright_txt, 'header': header_txt, 'body': body_txt, 'footer': footer_txt}
+ # TODO : Set a default copyright & footer at least
+
+ def setFilename(self, filename):
+ self.filename = filename
+
+ def setCopyright(self, c):
+ self.contents['copyright'] = c
+
+ def setHeader(self, h):
+ self.contents['header'] = h
+
+ def setBody(self, b):
+ self.contents['body'] = b
+
+ def setFooter(self, f):
+ self.contents['footer'] = f
+
+ def generate(self):
+ #print("Generate to file %s" % self.filename)
+ with open(self.filename, "w") as f:
+ f.write(self.contents['copyright'])
+ f.write(self.contents['header'])
+ f.write(self.contents['body'])
+ f.write(self.contents['footer'])
+
+# class for writing a wrapper class for structures
+# The wrapper class wraps the structs and includes utility functions for
+# setting/getting member values and displaying the struct data in various formats
+class StructWrapperGen:
+ def __init__(self, in_struct_dict, prefix, out_dir):
+ self.struct_dict = in_struct_dict
+ self.include_headers = []
+ self.api = prefix
+ self.header_filename = os.path.join(out_dir, self.api+"_struct_wrappers.h")
+ self.class_filename = os.path.join(out_dir, self.api+"_struct_wrappers.cpp")
+ self.string_helper_filename = os.path.join(out_dir, self.api+"_struct_string_helper.h")
+ self.hfg = CommonFileGen(self.header_filename)
+ self.cfg = CommonFileGen(self.class_filename)
+ self.shg = CommonFileGen(self.string_helper_filename)
+ #print(self.header_filename)
+ self.header_txt = ""
+ self.definition_txt = ""
+
+ def set_include_headers(self, include_headers):
+ self.include_headers = include_headers
+
+ # Return class name for given struct name
+ def get_class_name(self, struct_name):
+ class_name = struct_name.strip('_').lower() + "_struct_wrapper"
+ return class_name
+
+ def get_file_list(self):
+ return [os.path.basename(self.header_filename), os.path.basename(self.class_filename), os.path.basename(self.string_helper_filename)]
+
+ # Generate class header file
+ def generateHeader(self):
+ self.hfg.setCopyright(self._generateCopyright())
+ self.hfg.setHeader(self._generateHeader())
+ self.hfg.setBody(self._generateClassDeclaration())
+ self.hfg.setFooter(self._generateFooter())
+ self.hfg.generate()
+
+ # Generate class definition
+ def generateBody(self):
+ self.cfg.setCopyright(self._generateCopyright())
+ self.cfg.setHeader(self._generateCppHeader())
+ self.cfg.setBody(self._generateClassDefinition())
+ self.cfg.setFooter(self._generateFooter())
+ self.cfg.generate()
+
+ # Generate c-style .h file that contains functions for printing structs
+ def generateStringHelper(self):
+ print("Generating struct string helper")
+ self.shg.setCopyright(self._generateCopyright())
+ self.shg.setHeader(self._generateHeader())
+ self.shg.setBody(self._generateStringHelperFunctions())
+ self.shg.generate()
+
+ def _generateCopyright(self):
+ return "//This is the copyright\n"
+
+ def _generateCppHeader(self):
+ header = []
+ header.append("//#includes, #defines, globals and such...\n")
+ header.append("#include <stdio.h>\n#include <%s>\n#include <%s_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api))
+ return "".join(header)
+
+ def _generateClassDefinition(self):
+ class_def = []
+ if 'xgl' == self.api: # Mantle doesn't have pNext to worry about
+ class_def.append(self._generateDynamicPrintFunctions())
+ for s in self.struct_dict:
+ class_def.append("\n// %s class definition" % self.get_class_name(s))
+ class_def.append(self._generateConstructorDefinitions(s))
+ class_def.append(self._generateDestructorDefinitions(s))
+ class_def.append(self._generateDisplayDefinitions(s))
+ return "\n".join(class_def)
+
+ def _generateConstructorDefinitions(self, s):
+ con_defs = []
+ con_defs.append("%s::%s() : m_struct(), m_indent(0), m_dummy_prefix('\\0'), m_origStructAddr(NULL) {}" % (self.get_class_name(s), self.get_class_name(s)))
+ # TODO : This is a shallow copy of ptrs
+ con_defs.append("%s::%s(%s* pInStruct) : m_indent(0), m_dummy_prefix('\\0')\n{\n m_struct = *pInStruct;\n m_origStructAddr = pInStruct;\n}" % (self.get_class_name(s), self.get_class_name(s), typedef_fwd_dict[s]))
+ con_defs.append("%s::%s(const %s* pInStruct) : m_indent(0), m_dummy_prefix('\\0')\n{\n m_struct = *pInStruct;\n m_origStructAddr = pInStruct;\n}" % (self.get_class_name(s), self.get_class_name(s), typedef_fwd_dict[s]))
+ return "\n".join(con_defs)
+
+ def _generateDestructorDefinitions(self, s):
+ return "%s::~%s() {}" % (self.get_class_name(s), self.get_class_name(s))
+
+ def _generateDynamicPrintFunctions(self):
+ dp_funcs = []
+ dp_funcs.append("\nvoid dynamic_display_full_txt(const XGL_VOID* pStruct, uint32_t indent)\n{\n // Cast to APP_INFO ptr initially just to pull sType off struct")
+ dp_funcs.append(" XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType; switch (sType)\n {")
+ for e in enum_type_dict:
+ class_num = 0
+ if "_STRUCTURE_TYPE" in e:
+ for v in sorted(enum_type_dict[e]):
+ struct_name = v.replace("_STRUCTURE_TYPE", "")
+ class_name = self.get_class_name(struct_name)
+ # TODO : Hand-coded fixes for some exceptions
+ if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name:
+ struct_name = 'XGL_PIPELINE_CB_STATE'
+ elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name:
+ struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO'
+ class_name = self.get_class_name(struct_name)
+ elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name:
+ struct_name = 'XGL_QUEUE_SEMAPHORE_OPEN_INFO'
+ class_name = self.get_class_name(struct_name)
+ instance_name = "swc%i" % class_num
+ dp_funcs.append(" case %s:\n {" % (v))
+ dp_funcs.append(" %s %s((%s*)pStruct);" % (class_name, instance_name, struct_name))
+ dp_funcs.append(" %s.set_indent(indent);" % (instance_name))
+ dp_funcs.append(" %s.display_full_txt();" % (instance_name))
+ dp_funcs.append(" }")
+ dp_funcs.append(" break;")
+ class_num += 1
+ dp_funcs.append(" }")
+ dp_funcs.append("}\n")
+ return "\n".join(dp_funcs)
+
+ def _get_sh_func_name(self, struct):
+ return "%s_print_%s" % (self.api, struct.lower().strip("_"))
+
+ # Return elements to create formatted string for given struct member
+ def _get_struct_print_formatted(self, struct_member, pre_var_name="prefix", postfix = "\\n", struct_var_name="pStruct", struct_ptr=True, print_array=False):
+ struct_op = "->"
+ if not struct_ptr:
+ struct_op = "."
+ member_name = struct_member['name']
+ print_type = "p"
+ cast_type = ""
+ member_post = ""
+ array_index = ""
+ member_print_post = ""
+ if struct_member['array'] and 'CHAR' in struct_member['type']: # just print char array as string
+ print_type = "s"
+ print_array = False
+ elif struct_member['array'] and not print_array:
+ # Just print base address of array when not full print_array
+ cast_type = "(void*)"
+ elif is_type(struct_member['type'], 'enum'):
+ cast_type = "string_%s" % struct_member['type']
+ print_type = "s"
+ elif is_type(struct_member['type'], 'struct'): # print struct address for now
+ cast_type = "(void*)"
+ if not struct_member['ptr']:
+ cast_type = "(void*)&"
+ elif 'BOOL' in struct_member['type']:
+ print_type = "s"
+ member_post = ' ? "TRUE" : "FALSE"'
+ elif 'FLOAT' in struct_member['type']:
+ print_type = "f"
+ elif 'UINT64' in struct_member['type']:
+ print_type = "lu"
+ elif 'UINT8' in struct_member['type']:
+ print_type = "hu"
+ elif True in [ui_str in struct_member['type'] for ui_str in ['UINT', '_SIZE', '_FLAGS', '_SAMPLE_MASK']]:
+ print_type = "u"
+ elif 'INT' in struct_member['type']:
+ print_type = "i"
+ elif struct_member['ptr']:
+ #cast_type = ""
+ pass
+ else:
+ #print("Unhandled struct type: %s" % struct_member['type'])
+ cast_type = "(void*)"
+ if print_array and struct_member['array']:
+ member_print_post = "[%u]"
+ array_index = " i,"
+ member_post = "[i]"
+ print_out = "%%s%s%s = %%%s%s" % (member_name, member_print_post, print_type, postfix) # section of print that goes inside of quotes
+ print_arg = ", %s,%s %s(%s%s%s)%s" % (pre_var_name, array_index, cast_type, struct_var_name, struct_op, member_name, member_post) # section of print passed to portion in quotes
+ return (print_out, print_arg)
+
+ def _generateStringHelperFunctions(self):
+ sh_funcs = []
+ # TODO : Need a nice way to unify all of the different struct type print formatting code
+ for s in self.struct_dict:
+ p_out = ""
+ p_args = ""
+ sh_funcs.append('char* %s(const %s* pStruct, const char* prefix)\n{\n char* str;\n str = (char*)malloc(sizeof(char)*1024);\n sprintf(str, "' % (self._get_sh_func_name(s), typedef_fwd_dict[s]))
+ for m in sorted(self.struct_dict[s]):
+ (p_out1, p_args1) = self._get_struct_print_formatted(self.struct_dict[s][m])
+ p_out += p_out1
+ p_args += p_args1
+ p_out += '"'
+ p_args += ");\n return str;\n}\n"
+ sh_funcs.append(p_out)
+ sh_funcs.append(p_args)
+ return "".join(sh_funcs)
+
+
+ def _genStructMemberPrint(self, member, s, array, struct_array):
+ (p_out, p_arg) = self._get_struct_print_formatted(self.struct_dict[s][member], pre_var_name="&m_dummy_prefix", struct_var_name="m_struct", struct_ptr=False, print_array=True)
+ extra_indent = ""
+ if array:
+ extra_indent = " "
+ if is_type(self.struct_dict[s][member]['type'], 'struct'): # print struct address for now
+ struct_array.insert(0, self.struct_dict[s][member])
+ elif self.struct_dict[s][member]['ptr']:
+ # Special case for VOID* named "pNext"
+ if "VOID" in self.struct_dict[s][member]['type'] and "pNext" == self.struct_dict[s][member]['name']:
+ struct_array.insert(0, self.struct_dict[s][member])
+ return (' %sprintf("%%*s %s", m_indent, ""%s);' % (extra_indent, p_out, p_arg), struct_array)
+
+ def _generateDisplayDefinitions(self, s):
+ disp_def = []
+ struct_array = []
+ # Single-line struct print function
+ disp_def.append("// Output 'structname = struct_address' on a single line")
+ disp_def.append("void %s::display_single_txt()\n{" % self.get_class_name(s))
+ disp_def.append(' printf(" %%*s%s = %%p", m_indent, "", (void*)m_origStructAddr);' % typedef_fwd_dict[s])
+ disp_def.append("}\n")
+ # Private helper function to print struct members
+ disp_def.append("// Private helper function that displays the members of the wrapped struct")
+ disp_def.append("void %s::display_struct_members()\n{" % self.get_class_name(s))
+ i_declared = False
+ for member in sorted(self.struct_dict[s]):
+ # TODO : Need to display each member based on its type
+ # TODO : Need to handle pNext which are structs, but of XGL_VOID* type
+ # Can grab struct type off of header of struct pointed to
+ # TODO : Handle Arrays
+ if self.struct_dict[s][member]['array']:
+ # Create for loop to print each element of array
+ if not i_declared:
+ disp_def.append(' uint32_t i;')
+ i_declared = True
+ disp_def.append(' for (i = 0; i<%s; i++) {' % self.struct_dict[s][member]['array_size'])
+ (return_str, struct_array) = self._genStructMemberPrint(member, s, True, struct_array)
+ disp_def.append(return_str)
+ disp_def.append(' }')
+ else:
+ (return_str, struct_array) = self._genStructMemberPrint(member, s, False, struct_array)
+ disp_def.append(return_str)
+ disp_def.append("}\n")
+ i_declared = False
+ # Basic print function to display struct members
+ disp_def.append("// Output all struct elements, each on their own line")
+ disp_def.append("void %s::display_txt()\n{" % self.get_class_name(s))
+ disp_def.append(' printf("%%*s%s struct contents at %%p:\\n", m_indent, "", (void*)m_origStructAddr);' % typedef_fwd_dict[s])
+ disp_def.append(' this->display_struct_members();')
+ disp_def.append("}\n")
+ # Advanced print function to display current struct and contents of any pointed-to structs
+ disp_def.append("// Output all struct elements, and for any structs pointed to, print complete contents")
+ disp_def.append("void %s::display_full_txt()\n{" % self.get_class_name(s))
+ disp_def.append(' printf("%%*s%s struct contents at %%p:\\n", m_indent, "", (void*)m_origStructAddr);' % typedef_fwd_dict[s])
+ disp_def.append(' this->display_struct_members();')
+ class_num = 0
+ # TODO : Need to handle arrays of structs here
+ for ms in struct_array:
+ swc_name = "class%s" % str(class_num)
+ if ms['array']:
+ if not i_declared:
+ disp_def.append(' uint32_t i;')
+ i_declared = True
+ disp_def.append(' for (i = 0; i<%s; i++) {' % ms['array_size'])
+ #disp_def.append(" if (m_struct.%s[i]) {" % (ms['name']))
+ disp_def.append(" %s %s(&(m_struct.%s[i]));" % (self.get_class_name(ms['type']), swc_name, ms['name']))
+ disp_def.append(" %s.set_indent(m_indent + 4);" % (swc_name))
+ disp_def.append(" %s.display_full_txt();" % (swc_name))
+ #disp_def.append(' }')
+ disp_def.append(' }')
+ elif 'pNext' == ms['name']:
+ # Need some code trickery here
+ # I'm thinking have a generated function that takes pNext ptr value
+ # then it checks sType and in large switch statement creates appropriate
+ # wrapper class type and then prints contents
+ disp_def.append(" if (m_struct.%s) {" % (ms['name']))
+ #disp_def.append(' printf("%*s This is where we would call dynamic print function\\n", m_indent, "");')
+ disp_def.append(' dynamic_display_full_txt(m_struct.%s, m_indent);' % (ms['name']))
+ disp_def.append(" }")
+ else:
+ if ms['ptr']:
+ disp_def.append(" if (m_struct.%s) {" % (ms['name']))
+ disp_def.append(" %s %s(m_struct.%s);" % (self.get_class_name(ms['type']), swc_name, ms['name']))
+ else:
+ disp_def.append(" if (&m_struct.%s) {" % (ms['name']))
+ disp_def.append(" %s %s(&m_struct.%s);" % (self.get_class_name(ms['type']), swc_name, ms['name']))
+ disp_def.append(" %s.set_indent(m_indent + 4);" % (swc_name))
+ disp_def.append(" %s.display_full_txt();\n }" % (swc_name))
+ class_num += 1
+ disp_def.append("}\n")
+ return "\n".join(disp_def)
+
+ def _generateHeader(self):
+ header = []
+ header.append("//#includes, #defines, globals and such...\n")
+ for f in self.include_headers:
+ header.append("#include <%s>\n" % f)
+ return "".join(header)
+
+ # Declarations
+ def _generateConstructorDeclarations(self, s):
+ constructors = []
+ constructors.append(" %s();\n" % self.get_class_name(s))
+ constructors.append(" %s(%s* pInStruct);\n" % (self.get_class_name(s), typedef_fwd_dict[s]))
+ constructors.append(" %s(const %s* pInStruct);\n" % (self.get_class_name(s), typedef_fwd_dict[s]))
+ return "".join(constructors)
+
+ def _generateDestructorDeclarations(self, s):
+ return " virtual ~%s();\n" % self.get_class_name(s)
+
+ def _generateDisplayDeclarations(self, s):
+ return " void display_txt();\n void display_single_txt();\n void display_full_txt();\n"
+
+ def _generateGetSetDeclarations(self, s):
+ get_set = []
+ get_set.append(" void set_indent(uint32_t indent) { m_indent = indent; }\n")
+ for member in sorted(self.struct_dict[s]):
+ # TODO : Skipping array set/get funcs for now
+ if self.struct_dict[s][member]['array']:
+ continue
+ get_set.append(" %s get_%s() { return m_struct.%s; }\n" % (self.struct_dict[s][member]['full_type'], self.struct_dict[s][member]['name'], self.struct_dict[s][member]['name']))
+ if not self.struct_dict[s][member]['const']:
+ get_set.append(" void set_%s(%s inValue) { m_struct.%s = inValue; }\n" % (self.struct_dict[s][member]['name'], self.struct_dict[s][member]['full_type'], self.struct_dict[s][member]['name']))
+ return "".join(get_set)
+
+ def _generatePrivateMembers(self, s):
+ priv = []
+ priv.append("\nprivate:\n")
+ priv.append(" %s m_struct;\n" % typedef_fwd_dict[s])
+ priv.append(" const %s* m_origStructAddr;\n" % typedef_fwd_dict[s])
+ priv.append(" uint32_t m_indent;\n")
+ priv.append(" const char m_dummy_prefix;\n")
+ priv.append(" void display_struct_members();\n")
+ return "".join(priv)
+
+ def _generateClassDeclaration(self):
+ class_decl = []
+ for s in self.struct_dict:
+ class_decl.append("\n//class declaration")
+ class_decl.append("class %s\n{\npublic:" % self.get_class_name(s))
+ class_decl.append(self._generateConstructorDeclarations(s))
+ class_decl.append(self._generateDestructorDeclarations(s))
+ class_decl.append(self._generateDisplayDeclarations(s))
+ class_decl.append(self._generateGetSetDeclarations(s))
+ class_decl.append(self._generatePrivateMembers(s))
+ class_decl.append("};\n")
+ return "\n".join(class_decl)
+
+ def _generateFooter(self):
+ return "\n//any footer info for class\n"
+
+class EnumCodeGen:
+ def __init__(self, enum_type_dict=None, enum_val_dict=None, typedef_fwd_dict=None, in_file=None, out_file=None):
+ self.et_dict = enum_type_dict
+ self.ev_dict = enum_val_dict
+ self.tf_dict = typedef_fwd_dict
+ self.in_file = in_file
+ self.out_file = out_file
+ self.efg = CommonFileGen(self.out_file)
+
+ def generateStringHelper(self):
+ self.efg.setHeader(self._generateSHHeader())
+ self.efg.setBody(self._generateSHBody())
+ self.efg.generate()
+
+ def _generateSHBody(self):
+ body = []
+# with open(self.out_file, "a") as hf:
+ # bet == base_enum_type, fet == final_enum_type
+ for bet in self.et_dict:
+ fet = self.tf_dict[bet]
+ body.append("static const char* string_%s(%s input_value)\n{\n switch ((%s)input_value)\n {\n" % (fet, fet, fet))
+ for e in sorted(self.et_dict[bet]):
+ if (self.ev_dict[e]['unique']):
+ body.append(' case %s:\n return "%s";\n' % (e, e))
+ body.append(' }\n return "Unhandled %s";\n}\n\n' % fet)
+ return "\n".join(body)
+
+ def _generateSHHeader(self):
+ return "#pragma once\n\n#include <%s>\n\n" % self.in_file
+
+
+class CMakeGen:
+ def __init__(self, struct_wrapper=None, out_dir=None):
+ self.sw = struct_wrapper
+ self.add_lib_file_list = self.sw.get_file_list()
+ self.out_dir = out_dir
+ self.out_file = os.path.join(self.out_dir, "CMakeLists.txt")
+ self.cmg = CommonFileGen(self.out_file)
+
+ def generate(self):
+ self.cmg.setBody(self._generateBody())
+ self.cmg.generate()
+
+ def _generateBody(self):
+ body = []
+ body.append("project(%s)" % os.path.basename(self.out_dir))
+ body.append("cmake_minimum_required(VERSION 2.8)\n")
+ body.append("add_library(${PROJECT_NAME} %s)\n" % " ".join(self.add_lib_file_list))
+ body.append('set(COMPILE_FLAGS "-fpermissive")')
+ body.append('set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS}")\n')
+ body.append("include_directories(${SRC_DIR}/thirdparty/${GEN_API}/inc/)\n")
+ body.append("target_include_directories (%s PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})\n" % os.path.basename(self.out_dir))
+ return "\n".join(body)
+
+class GraphVizGen:
+ def __init__(self, struct_dict=None):
+ self.struc_dict = struct_dict
+ self.out_file = os.path.join(os.getcwd(), "struct_gv.dot")
+ self.gvg = CommonFileGen(self.out_file)
+
+ def generate(self):
+ self.gvg.setHeader(self._generateHeader())
+ self.gvg.setBody(self._generateBody())
+ self.gvg.setFooter('}')
+ self.gvg.generate()
+
+ def _generateHeader(self):
+ hdr = []
+ hdr.append('digraph g {\ngraph [\nrankdir = "LR"\n];')
+ hdr.append('node [\nfontsize = "16"\nshape = "plaintext"\n];')
+ hdr.append('edge [\n];\n')
+ return "\n".join(hdr)
+
+ def _generateBody(self):
+ body = []
+ for s in self.struc_dict:
+ field_num = 1
+ body.append('"%s" [\nlabel = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">%s</TD></TR>' % (s, typedef_fwd_dict[s]))
+ for m in sorted(self.struc_dict[s]):
+ body.append('<TR><TD PORT="f%i">%s</TD><TD PORT="f%i">%s</TD></TR>' % (field_num, self.struc_dict[s][m]['full_type'], field_num+1, self.struc_dict[s][m]['name']))
+ field_num += 2
+ body.append('</TABLE>>\n];\n')
+ return "".join(body)
+
+
+def main(argv=None):
+ opts = handle_args()
+ # Parse input file and fill out global dicts
+ hfp = HeaderFileParser(opts.input_file)
+ hfp.parse()
+ # TODO : Don't want these to be global, see note at top about wrapper classes
+ global enum_val_dict
+ global enum_type_dict
+ global struct_dict
+ global typedef_fwd_dict
+ global typedef_rev_dict
+ global types_dict
+ enum_val_dict = hfp.get_enum_val_dict()
+ enum_type_dict = hfp.get_enum_type_dict()
+ struct_dict = hfp.get_struct_dict()
+ typedef_fwd_dict = hfp.get_typedef_fwd_dict()
+ typedef_rev_dict = hfp.get_typedef_rev_dict()
+ types_dict = hfp.get_types_dict()
+ #print(enum_val_dict)
+ #print(typedef_dict)
+ #print(struct_dict)
+ if (opts.abs_out_dir is not None):
+ enum_filename = os.path.join(opts.abs_out_dir, os.path.basename(opts.input_file).strip(".h")+"_string_helper.h")
+ else:
+ enum_filename = os.path.join(os.getcwd(), opts.rel_out_dir, os.path.basename(opts.input_file).strip(".h")+"_string_helper.h")
+ enum_filename = os.path.abspath(enum_filename)
+ if not os.path.exists(os.path.dirname(enum_filename)):
+ print("Creating output dir %s" % os.path.dirname(enum_filename))
+ os.mkdir(os.path.dirname(enum_filename))
+ print("Generating enum string helper to %s" % enum_filename)
+ eg = EnumCodeGen(enum_type_dict, enum_val_dict, typedef_fwd_dict, os.path.basename(opts.input_file), enum_filename)
+ eg.generateStringHelper()
+ #for struct in struct_dict:
+ #print(struct)
+ sw = StructWrapperGen(struct_dict, os.path.basename(opts.input_file).strip(".h"), os.path.dirname(enum_filename))
+ #print(sw.get_class_name(struct))
+ sw.set_include_headers([os.path.basename(opts.input_file),os.path.basename(enum_filename),"stdint.h","stdio.h","stdlib.h"])
+ print("Generating struct wrapper header to %s" % sw.header_filename)
+ sw.generateHeader()
+ print("Generating struct wrapper class to %s" % sw.class_filename)
+ sw.generateBody()
+ sw.generateStringHelper()
+ cmg = CMakeGen(sw, os.path.dirname(enum_filename))
+ cmg.generate()
+ print("DONE! Check out the file, but we're still early so assume something's probably not quite right. :)")
+ gv = GraphVizGen(struct_dict)
+ gv.generate()
+ #print(typedef_rev_dict)
+ #print(types_dict)
+ #recreate_structs()
+
+if __name__ == "__main__":
+ sys.exit(main())
+
+
+## Example class for GR_APPLICATION_INFO struct
+##include <mantle.h>
+#
+#class gr_application_info_struct_wrapper {
+#public:
+# // Constructors
+# gr_application_info_struct_wrapper();
+# gr_application_info_struct_wrapper(GR_APPLICATION_INFO* pInStruct);
+# // Destructor
+# virtual ~gr_application_info_struct_wrapper();
+#
+# void display_txt()
+# // get functions
+# // set functions for every non-const struct member
+#
+#private:
+# GR_APPLICATION_INFO m_struct;
+#};
+#
+#gr_application_info_struct_wrapper::gr_application_info_struct_wrapper() : m_struct() {}
+#
+#// Output struct address on single line
+#gr_application_info_struct_wrapper::display_single_txt()
+#{
+# printf(" GR_APPLICATION_INFO = %p", &m_struct);
+#}
+#// Output struct in txt format
+#gr_application_info_struct_wrapper::display_txt()
+#{
+# printf("GR_APPLICATION_INFO struct contents:\n");
+# printf(" pAppName: %s\n", m_struct.pAppName);
+# printf(" appVersion: %i\n", m_struct.appVersion);
+# printf(" pEngineNmae: %s\n", m_struct.pEngineName);
+# printf(" engineVersion: %i\n", m_struct.engineVersion);
+# printf(" apiVersion: %i\n", m_struct.apiVersion);
+#}
+#// Output struct including detailed info on pointed-to structs
+#gr_application_info_struct_wrapper::display_full_txt()
+#{
+#
+# printf("%*s%GR_APPLICATION_INFO struct contents:\n", indent, "");
+# printf(" pAppName: %s\n", m_struct.pAppName);
+# printf(" appVersion: %i\n", m_struct.appVersion);
+# printf(" pEngineNmae: %s\n", m_struct.pEngineName);
+# printf(" engineVersion: %i\n", m_struct.engineVersion);
+# printf(" apiVersion: %i\n", m_struct.apiVersion);
+#}
+
+
+# Example of helper function to pretty-print enum info
+#static const char* string_GR_RESULT_CODE(GR_RESULT result)
+#{
+# switch ((GR_RESULT_CODE)result)
+# {
+# // Return codes for successful operation execution
+# case GR_SUCCESS:
+# return "GR_SUCCESS";
+# case GR_UNSUPPORTED:
+# return "GR_UNSUPPORTED";
+# case GR_NOT_READY:
+# return "GR_NOT_READY";
+# case GR_TIMEOUT:
+# return "GR_TIMEOUT";
+# }
+# return "Unhandled GR_RESULT_CODE";
+#}
+
+# Dynamic print function
+# void dynamic_display_full_txt(XGL_STRUCTURE_TYPE sType, void* pStruct, uint32_t indent)
+# {
+# switch (sType)
+# {
+# case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO:
+# xgl_color_blend_state_create_info_struct_wrapper swc((XGL_COLOR_BLEND_STATE_CREATE_INFO*)pStruct);
+# swc.set_indent(indent);
+# swc.display_full_txt();
+# }
+# }
diff --git a/tools/glave/src/LICENSE b/tools/glave/src/LICENSE
new file mode 100644
index 0000000..4f04ead
--- /dev/null
+++ b/tools/glave/src/LICENSE
@@ -0,0 +1,22 @@
+Copyright 2014 Valve Software
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
diff --git a/tools/glave/src/build_options.cmake b/tools/glave/src/build_options.cmake
new file mode 100644
index 0000000..b258152
--- /dev/null
+++ b/tools/glave/src/build_options.cmake
@@ -0,0 +1,503 @@
+#
+# cmake -DCMAKE_BUILD_TYPE=Debug ..
+#
+# http://www.cmake.org/Wiki/CMake_FAQ
+# http://www.cmake.org/Wiki/CMake_Useful_Variables
+# http://clang.llvm.org/docs/LanguageExtensions.html
+#
+#
+cmake_minimum_required(VERSION 2.8)
+
+set(BUILD_X64 "" CACHE STRING "whether to perform 64-bit build: ON or OFF overrides default detection")
+
+option(CMAKE_VERBOSE "Verbose CMake" FALSE)
+if (CMAKE_VERBOSE)
+ SET(CMAKE_VERBOSE_MAKEFILE ON)
+endif()
+
+# With gcc48: http://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=230762
+
+option(WITH_HARDENING "Enable hardening: Compile-time protection against static sized buffer overflows" OFF)
+
+# Unless user specifies BUILD_X64 explicitly, assume native target
+if (BUILD_X64 STREQUAL "")
+ if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+ set(BUILD_X64 "TRUE")
+ else()
+ set(BUILD_X64 "FALSE")
+ endif()
+endif()
+
+# Generate bitness suffix to use, but make sure to include the existing suffix (.exe)
+# for platforms that need it (ie, Windows)
+if (BUILD_X64)
+ set(CMAKE_EXECUTABLE_SUFFIX "64${CMAKE_EXECUTABLE_SUFFIX}")
+ set(CMAKE_SHARED_LIBRARY_SUFFIX "64${CMAKE_SHARED_LIBRARY_SUFFIX}")
+else()
+ set(CMAKE_EXECUTABLE_SUFFIX "32${CMAKE_EXECUTABLE_SUFFIX}")
+ set(CMAKE_SHARED_LIBRARY_SUFFIX "32${CMAKE_SHARED_LIBRARY_SUFFIX}")
+endif()
+
+# Default to release build
+if (NOT CMAKE_BUILD_TYPE)
+ set(CMAKE_BUILD_TYPE Release)
+endif()
+
+# Make sure we're using 64-bit versions of stat, fopen, etc.
+# Large File Support extensions:
+# http://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html#Feature-Test-Macros
+add_definitions(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGE_FILES)
+
+# support for inttypes.h macros
+add_definitions(-D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_CONSTANT_MACROS)
+
+if(MSVC)
+ set(CMAKE_CXX_FLAGS_LIST "/W3 /D_CRT_SECURE_NO_WARNINGS=1 /DWIN32 /D_WIN32")
+ set(CMAKE_CXX_FLAGS_RELEASE_LIST "/O2 /DNDEBUG")
+ set(CMAKE_CXX_FLAGS_DEBUG_LIST "/Od /D_DEBUG")
+else()
+ set(CMAKE_CXX_FLAGS_LIST "-g -Wall -Wextra")
+ set(CMAKE_CXX_FLAGS_RELEASE_LIST "-g -O2 -DNDEBUG")
+ set(CMAKE_CXX_FLAGS_DEBUG_LIST "-g -O0 -D_DEBUG")
+endif()
+
+
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+
+ # clang doesn't print colored diagnostics when invoked from Ninja
+ if (UNIX AND CMAKE_GENERATOR STREQUAL "Ninja")
+ add_definitions ("-fcolor-diagnostics")
+ endif()
+
+ if (CLANG_EVERYTHING)
+ set(CMAKE_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS_LIST}
+ # "-pedantic" # Warn on language extensions
+ "-Weverything" # Enable all warnings
+ "-fdiagnostics-show-category=name"
+ "-Wno-unused-macros"
+ "-Wno-padded"
+ "-Wno-variadic-macros"
+ "-Wno-missing-variable-declarations"
+ "-Wno-missing-prototypes"
+ "-Wno-sign-conversion"
+ "-Wno-conversion"
+ "-Wno-cast-align"
+ "-Wno-exit-time-destructors"
+ "-Wno-documentation-deprecated-sync"
+ "-Wno-documentation-unknown-command"
+
+ # TODO: Would be great to start enabling some of these warnings...
+ "-Wno-undefined-reinterpret-cast"
+ "-Wno-incompatible-pointer-types-discards-qualifiers"
+ "-Wno-float-equal"
+ "-Wno-unreachable-code"
+ "-Wno-weak-vtables"
+ "-Wno-extra-semi"
+ "-Wno-disabled-macro-expansion"
+ "-Wno-format-nonliteral"
+ "-Wno-packed"
+ "-Wno-c++11-long-long"
+ "-Wno-c++11-extensions"
+ "-Wno-gnu-anonymous-struct"
+ "-Wno-gnu-zero-variadic-macro-arguments"
+ "-Wno-nested-anon-types"
+ "-Wno-gnu-redeclared-enum"
+
+ "-Wno-pedantic"
+ "-Wno-header-hygiene"
+ "-Wno-covered-switch-default"
+ "-Wno-duplicate-enum"
+ "-Wno-switch-enum"
+ "-Wno-extra-tokens"
+
+ # Added because SDL2 headers have a ton of Doxygen warnings currently.
+ "-Wno-documentation"
+
+ )
+ endif()
+
+endif()
+
+
+if ((NOT MSVC) AND (NOT BUILD_X64) AND (CMAKE_SIZEOF_VOID_P EQUAL 8))
+ set(CMAKE_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS_LIST} -m32")
+ set(CMAKE_EXE_LINK_FLAGS_LIST "${CMAKE_EXE_LINK_FLAGS_LIST} -m32")
+ set(CMAKE_SHARED_LINK_FLAGS_LIST "${CMAKE_SHARED_LINK_FLAGS_LIST} -m32")
+
+ set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS OFF)
+ set(CMAKE_SYSTEM_LIBRARY_PATH /lib32 /usr/lib32 /usr/lib/i386-linux-gnu /usr/local/lib32)
+ set(CMAKE_IGNORE_PATH /lib /usr/lib /usr/lib/x86_64-linux-gnu /usr/lib64 /usr/local/lib)
+endif()
+
+function(add_compiler_flag flag)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
+endfunction()
+
+function(add_compiler_flag_debug flag)
+ set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${flag}" PARENT_SCOPE)
+ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${flag}" PARENT_SCOPE)
+endfunction()
+
+function(add_compiler_flag_release flag)
+ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${flag}" PARENT_SCOPE)
+ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${flag}" PARENT_SCOPE)
+endfunction()
+
+
+function(add_linker_flag flag)
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}" PARENT_SCOPE)
+endfunction()
+
+function(add_shared_linker_flag flag)
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${flag}" PARENT_SCOPE)
+endfunction()
+
+#
+# To show the include files as you're building, do this:
+# add_compiler_flag("-H")
+# For Visual Studio, it's /showIncludes I believe...
+#
+
+# stack-protector-strong: http://gcc.gnu.org/ml/gcc-patches/2012-06/msg00974.html
+## -fstack-protector-strong
+# Compile with the option "-fstack-usage" and a file .su will be generated with stack
+# information for each function.
+## -fstack-usage
+
+# For more info on -fno-strict-aliasing: "Just Say No to strict aliasing optimizations in C": http://nothings.org/
+# The Linux kernel is compiled with -fno-strict-aliasing: https://lkml.org/lkml/2003/2/26/158 or http://www.mail-archive.com/linux-btrfs@vger.kernel.org/msg01647.html
+
+### TODO: see if sse is generated with these instructions and clang:
+## -march=corei7 -msse -mfpmath=sse
+
+set(MARCH_STR "-march=corei7")
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+ if ( NOT BUILD_X64 )
+ # Fix startup crash in dlopen_notify_callback (called indirectly from our dlopen() function) when tracing glxspheres on my AMD dev box (x86 release only)
+ # Also fixes tracing Q3 Arena using release tracer
+ # Clang is generating sse2 code even when it shouldn't be:
+ # http://lists.cs.uiuc.edu/pipermail/cfe-dev/2012-March/020310.html
+ set(MARCH_STR "-march=i586")
+ endif()
+endif()
+
+if(MSVC)
+ set(CMAKE_CXX_FLAGS_LIST
+ ${CMAKE_CXX_FLAGS_LIST}
+ "/EHsc" # Need exceptions
+ )
+else()
+ set(CMAKE_CXX_FLAGS_LIST
+ ${CMAKE_CXX_FLAGS_LIST}
+ "-fno-omit-frame-pointer"
+ ${MARCH_STR}
+ # "-msse2 -mfpmath=sse" # To build with SSE instruction sets
+ "-Wno-unused-parameter -Wno-unused-function"
+ "-fno-strict-aliasing" # DO NOT remove this, we have lots of code that will fail in obscure ways otherwise because it was developed with MSVC first.
+ "-fno-math-errno"
+ "-fvisibility=hidden"
+ # "-fno-exceptions" # Exceptions are enabled by default for c++ files, disabled for c files.
+ )
+endif()
+
+if (CMAKE_COMPILER_IS_GNUCC)
+ execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+ string(REGEX MATCHALL "[0-9]+" GCC_VERSION_COMPONENTS ${GCC_VERSION})
+ list(GET GCC_VERSION_COMPONENTS 0 GCC_MAJOR)
+ list(GET GCC_VERSION_COMPONENTS 1 GCC_MINOR)
+ # message(STATUS "Detected GCC v ${GCC_MAJOR} . ${GCC_MINOR}")
+endif()
+
+if (GCC_VERSION VERSION_GREATER 4.8 OR GCC_VERSION VERSION_EQUAL 4.8)
+ set(CMAKE_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS_LIST}
+ "-Wno-unused-local-typedefs"
+ )
+endif()
+
+if (MSVC)
+else()
+ if (WITH_HARDENING)
+ # http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html
+ add_definitions(-D_FORTIFY_SOURCE=2 -fpic)
+ if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+ # During program load, several ELF memory sections need to be written to by the
+ # linker, but can be turned read-only before turning over control to the
+ # program. This prevents some GOT (and .dtors) overwrite attacks, but at least
+ # the part of the GOT used by the dynamic linker (.got.plt) is still vulnerable.
+ add_definitions(-pie -z now -z relro)
+ endif()
+ endif()
+endif()
+
+if (NOT MSVC)
+ set(CMAKE_EXE_LINK_FLAGS_LIST "-Wl,--no-undefined")
+
+endif()
+
+# Compiler flags
+string(REPLACE ";" " " CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS_LIST}")
+string(REPLACE ";" " " CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_LIST}")
+string(REPLACE ";" " " CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_LIST}")
+
+string(REPLACE ";" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_LIST}")
+string(REPLACE ";" " " CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_LIST}")
+string(REPLACE ";" " " CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_LIST}")
+
+# Linker flags (exe)
+string(REPLACE ";" " " CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINK_FLAGS_LIST}")
+# Linker flags (shared)
+string(REPLACE ";" " " CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINK_FLAGS_LIST}")
+
+# If building from inside chroot project, use glv_build there.
+if (EXISTS "${CMAKE_SOURCE_DIR}/../bin/chroot_build.sh")
+ set(RADPROJ_BUILD_DIR ${CMAKE_SOURCE_DIR}/../glv_build)
+else()
+ set(RADPROJ_BUILD_DIR ${CMAKE_SOURCE_DIR}/glv_build)
+endif()
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${RADPROJ_BUILD_DIR})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${RADPROJ_BUILD_DIR})
+
+function(build_options_finalize)
+ if (CMAKE_VERBOSE)
+ message(" CMAKE_PROJECT_NAME: ${CMAKE_PROJECT_NAME}")
+ message(" PROJECT_NAME: ${PROJECT_NAME}")
+ message(" BUILD_X64: ${BUILD_X64}")
+ message(" BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
+ message(" PROJECT_BINARY_DIR: ${PROJECT_BINARY_DIR}")
+ message(" CMAKE_SOURCE_DIR: ${CMAKE_SOURCE_DIR}")
+ message(" PROJECT_SOURCE_DIR: ${PROJECT_SOURCE_DIR}")
+ message(" CMAKE_CURRENT_LIST_FILE: ${CMAKE_CURRENT_LIST_FILE}")
+ message(" CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
+ message(" CXX_FLAGS_RELEASE: ${CMAKE_CXX_FLAGS_RELEASE}")
+ message(" CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
+ message(" EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
+ message(" SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}")
+ message(" SHARED_LIBRARY_C_FLAGS: ${CMAKE_SHARED_LIBRARY_C_FLAGS}")
+ message(" SHARED_LIBRARY_CXX_FLAGS: ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}")
+ message(" SHARED_LIBRARY_LINK_CXX_FLAGS: ${CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS}")
+ message(" SHARED_LIBRARY_LINK_C_FLAGS: ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS}")
+ message(" CMAKE_C_COMPILER: ${CMAKE_C_COMPILER}")
+ message(" CMAKE_CXX_COMPILER: ${CMAKE_CXX_COMPILER}")
+ message(" CMAKE_C_COMPILER_ID: ${CMAKE_C_COMPILER_ID}")
+ message(" CMAKE_EXECUTABLE_SUFFIX: ${CMAKE_EXECUTABLE_SUFFIX}")
+ message("")
+ endif()
+endfunction()
+
+function(require_pthreads)
+ find_package(Threads)
+ if (NOT CMAKE_USE_PTHREADS_INIT AND NOT WIN32_PTHREADS_INCLUDE_PATH)
+ message(FATAL_ERROR "pthread not found")
+ endif()
+
+ if (MSVC)
+ include_directories("${WIN32_PTHREADS_INCLUDE_PATH}")
+ if (BUILD_X64)
+ set(PTHREAD_SRC_LIB "${WIN32_PTHREADS_PATH}/lib/x64/pthreadVC2.lib" PARENT_SCOPE)
+ set(PTHREAD_SRC_DLL "${WIN32_PTHREADS_PATH}/dll/x64/pthreadVC2.dll" PARENT_SCOPE)
+ else()
+ set(PTHREAD_SRC_LIB "${WIN32_PTHREADS_PATH}/lib/x86/pthreadVC2.lib" PARENT_SCOPE)
+ set(PTHREAD_SRC_DLL "${WIN32_PTHREADS_PATH}/dll/x86/pthreadVC2.dll" PARENT_SCOPE)
+ endif()
+
+ else()
+ # Export the variable to the parent scope so the linker knows where to find the library.
+ set(CMAKE_THREAD_LIBS_INIT ${CMAKE_THREAD_LIBS_INIT} PARENT_SCOPE)
+ endif()
+endfunction()
+
+function(require_libjpegturbo)
+ find_library(LibJpegTurbo_LIBRARY
+ NAMES libturbojpeg.so libturbojpeg.so.0 libturbojpeg.dylib
+ PATHS /opt/libjpeg-turbo/lib
+ )
+
+ # On platforms that find this, the include files will have also been installed to the system
+ # so we don't need extra include dirs.
+ if (LibJpegTurbo_LIBRARY)
+ set(LibJpegTurbo_INCLUDE "" PARENT_SCOPE)
+ else()
+ if (BUILD_X64)
+ set(BITS_STRING "x64")
+ else()
+ set(BITS_STRING "x86")
+ endif()
+ set(LibJpegTurbo_INCLUDE "${CMAKE_PREFIX_PATH}/libjpeg-turbo-2.1.3/include" PARENT_SCOPE)
+ set(LibJpegTurbo_LIBRARY "${CMAKE_PREFIX_PATH}/libjpeg-turbo-2.1.3/lib_${BITS_STRING}/turbojpeg.lib" PARENT_SCOPE)
+ endif()
+endfunction()
+
+function(require_sdl2)
+ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ include(FindPkgConfig)
+ pkg_search_module(PC_SDL2 REQUIRED sdl2)
+
+ find_path(SDL2_INCLUDE SDL.h
+ DOC "SDL2 Include Path"
+ HINTS ${PC_SDL2_INCLUDEDIR} ${PC_SDL2_INCLUDE_DIRS} )
+
+ find_library(SDL2_LIBRARY SDL2
+ DOC "SDL2 Library"
+ HINTS ${PC_SDL2_LIBDIR} ${PC_SDL2_LIBRARY_DIRS} )
+ elseif (MSVC)
+ set(SDL2Root "${CMAKE_EXTERNAL_PATH}/SDL")
+
+ set(SDL2_INCLUDE "${SDL2Root}/include" CACHE PATH "SDL2 Include Path")
+ set(SDL2_LIBRARY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/SDL2.lib" CACHE FILEPATH "SDL2 Library")
+
+ # Only want to include this once.
+ # This has to go into properties because it needs to persist across the entire cmake run.
+ get_property(SDL_PROJECT_ALREADY_INCLUDED
+ GLOBAL
+ PROPERTY SDL_PROJECT_INCLUDED
+ )
+
+ if (NOT SDL_PROJECT_ALREADY_INCLUDED)
+ INCLUDE_EXTERNAL_MSPROJECT(SDL "${SDL2Root}/VisualC/SDL/SDL_VS2013.vcxproj")
+ set_property(GLOBAL
+ PROPERTY SDL_PROJECT_INCLUDED "TRUE"
+ )
+ message("Including SDL_VS2013.vcxproj for you!")
+ endif()
+
+ else()
+ message(FATAL_ERROR "Need to deal with SDL on non-Windows platforms")
+ endif()
+endfunction()
+
+function(require_m)
+ if (MSVC)
+ set(M_LIBRARY "winmm.lib" PARENT_SCOPE)
+ else()
+ set(M_LIBRARY "m" PARENT_SCOPE)
+ endif()
+endfunction()
+
+function(require_gl)
+ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ include(FindPkgConfig)
+ pkg_search_module(PC_GL QUIET gl)
+
+ find_path(GL_INCLUDE GL/gl.h
+ DOC "OpenGL Include Path"
+ HINTS ${PC_GL_INCLUDEDIR} ${PC_GL_INCLUDE_DIRS} )
+
+ find_library(GL_LIBRARY GL
+ DOC "OpenGL Library"
+ HINTS ${PC_GL_LIBDIR} ${PC_GL_LIBRARY_DIRS} )
+ elseif (MSVC)
+ set(GL_INCLUDE "" CACHE PATH "OpenGL Include Path")
+ set(GL_LIBRARY "opengl32.lib" CACHE FILEPATH "OpenGL Library")
+ else()
+ set(GL_INCLUDE "" CACHE PATH "OpenGL Include Path")
+ set(GL_LIBRARY "GL" CACHE FILEPATH "OpenGL Library")
+ endif()
+endfunction()
+
+function(require_glu)
+ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ include(FindPkgConfig)
+ pkg_search_module(PC_GLU QUIET glu)
+
+ find_path(GLU_INCLUDE GL/glu.h
+ DOC "GLU Include Path"
+ HINTS ${PC_GLU_INCLUDEDIR} ${PC_GLU_INCLUDE_DIRS} )
+
+ find_library(GLU_LIBRARY GLU
+ DOC "GLU Library"
+ HINTS ${PC_GLU_LIBDIR} ${PC_GLU_LIBRARY_DIRS} )
+ elseif (MSVC)
+ set(GLU_INCLUDE "" CACHE PATH "GLU Include Path")
+ set(GLU_LIBRARY "glu32.lib" CACHE FILEPATH "GLU Library")
+ else()
+ set(GLU_INCLUDE "" CACHE PATH "GLU Include Path")
+ set(GLU_LIBRARY "GLU" CACHE FILEPATH "GLU Library")
+ endif()
+endfunction()
+
+function(request_backtrace)
+ if (NOT MSVC)
+ set( LibBackTrace_INCLUDE "${SRC_DIR}/libbacktrace" PARENT_SCOPE )
+ set( LibBackTrace_LIBRARY "backtracevogl" PARENT_SCOPE )
+ else()
+ set( LibBackTrace_INCLUDE "" PARENT_SCOPE )
+ set( LibBackTrace_LIBRARY "" PARENT_SCOPE )
+ endif()
+endfunction()
+
+# What compiler toolchain are we building on?
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+ add_compiler_flag("-DCOMPILER_GCC=1")
+ add_compiler_flag("-DCOMPILER_GCCLIKE=1")
+elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "mingw")
+ add_compiler_flag("-DCOMPILER_MINGW=1")
+ add_compiler_flag("-DCOMPILER_GCCLIKE=1")
+elseif (MSVC)
+ add_compiler_flag("-DCOMPILER_MSVC=1")
+elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
+ add_compiler_flag("-DCOMPILER_CLANG=1")
+ add_compiler_flag("-DCOMPILER_GCCLIKE=1")
+else()
+ message("Compiler is ${CMAKE_C_COMPILER_ID}")
+ message(FATAL_ERROR "Compiler unset, build will fail--stopping at CMake time.")
+endif()
+
+# Platform specific libary defines.
+if (WIN32)
+ set( LIBRT "" )
+ set( LIBDL "" )
+
+elseif (UNIX)
+ set( LIBRT rt )
+ set( LIBDL dl )
+else()
+ message(FATAL_ERROR "Need to determine what the library name for 'rt' is for non-windows, non-unix platforms (or if it's even needed).")
+endif()
+
+# What OS will we be running on?
+if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ add_compiler_flag("-DPLATFORM_OSX=1")
+ add_compiler_flag("-DPLATFORM_POSIX=1")
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ add_compiler_flag("-DPLATFORM_LINUX=1")
+ add_compiler_flag("-DPLATFORM_POSIX=1")
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+ add_compiler_flag("-DPLATFORM_WINDOWS=1")
+else()
+ message(FATAL_ERROR "Platform unset, build will fail--stopping at CMake time.")
+endif()
+
+# What bittedness are we building?
+if (BUILD_X64)
+ add_compiler_flag("-DPLATFORM_64BIT=1")
+else()
+ add_compiler_flag("-DPLATFORM_32BIT=1")
+endif()
+
+# Compiler flags for windows.
+if (MSVC)
+ # Multithreaded compilation is a big time saver.
+ add_compiler_flag("/MP")
+
+ # In debug, we use the DLL debug runtime.
+ add_compiler_flag_debug("/MDd")
+
+ # And in release we use the DLL release runtime
+ add_compiler_flag_release("/MD")
+
+ # x64 doesn't ever support /ZI, only /Zi.
+ if (BUILD_X64)
+ add_compiler_flag("/Zi")
+ else()
+
+ # In debug, get debug information suitable for Edit and Continue
+ add_compiler_flag_debug("/ZI")
+
+ # In release, still generate debug information (because not having it is dumb)
+ add_compiler_flag_release("/Zi")
+ endif()
+
+ # And tell the linker to always generate the file for us.
+ add_linker_flag("/DEBUG")
+endif()
diff --git a/tools/glave/src/glv_extensions/glave_xgl_gen/CMakeLists.txt b/tools/glave/src/glv_extensions/glave_xgl_gen/CMakeLists.txt
new file mode 100644
index 0000000..588a834
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glave_xgl_gen/CMakeLists.txt
@@ -0,0 +1,11 @@
+project(glave_xgl_gen)
+cmake_minimum_required(VERSION 2.8)
+
+add_library(${PROJECT_NAME} xgl_struct_wrappers.h xgl_struct_wrappers.cpp xgl_struct_string_helper.h)
+
+set(COMPILE_FLAGS "-fpermissive")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS}")
+
+include_directories(${SRC_DIR}/thirdparty/${GEN_API}/inc/)
+
+target_include_directories (glave_xgl_gen PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_string_helper.h b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_string_helper.h
new file mode 100644
index 0000000..012eaa9
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_string_helper.h
@@ -0,0 +1,1621 @@
+#pragma once
+
+#include <xgl.h>
+
+static const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
+
+ }
+ return "Unhandled XGL_MEMORY_PRIORITY";
+}
+
+
+static const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+{
+ switch ((XGL_IMAGE_ASPECT)input_value)
+ {
+
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
+
+ }
+ return "Unhandled XGL_IMAGE_ASPECT";
+}
+
+
+static const char* string_XGL_NUM_FORMAT(XGL_NUM_FORMAT input_value)
+{
+ switch ((XGL_NUM_FORMAT)input_value)
+ {
+
+ case XGL_NUM_FMT_DS:
+ return "XGL_NUM_FMT_DS";
+
+ case XGL_NUM_FMT_FLOAT:
+ return "XGL_NUM_FMT_FLOAT";
+
+ case XGL_NUM_FMT_SINT:
+ return "XGL_NUM_FMT_SINT";
+
+ case XGL_NUM_FMT_SNORM:
+ return "XGL_NUM_FMT_SNORM";
+
+ case XGL_NUM_FMT_SRGB:
+ return "XGL_NUM_FMT_SRGB";
+
+ case XGL_NUM_FMT_UINT:
+ return "XGL_NUM_FMT_UINT";
+
+ case XGL_NUM_FMT_UNDEFINED:
+ return "XGL_NUM_FMT_UNDEFINED";
+
+ case XGL_NUM_FMT_UNORM:
+ return "XGL_NUM_FMT_UNORM";
+
+ }
+ return "Unhandled XGL_NUM_FORMAT";
+}
+
+
+static const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+
+ }
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+}
+
+
+static const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ {
+
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+
+ }
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+}
+
+
+static const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
+
+ }
+ return "Unhandled XGL_TEX_FILTER";
+}
+
+
+static const char* string_XGL_DESCRIPTOR_SET_SLOT_TYPE(XGL_DESCRIPTOR_SET_SLOT_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_SLOT_TYPE)input_value)
+ {
+
+ case XGL_SLOT_NEXT_DESCRIPTOR_SET:
+ return "XGL_SLOT_NEXT_DESCRIPTOR_SET";
+
+ case XGL_SLOT_SHADER_RESOURCE:
+ return "XGL_SLOT_SHADER_RESOURCE";
+
+ case XGL_SLOT_SHADER_SAMPLER:
+ return "XGL_SLOT_SHADER_SAMPLER";
+
+ case XGL_SLOT_SHADER_UAV:
+ return "XGL_SLOT_SHADER_UAV";
+
+ case XGL_SLOT_UNUSED:
+ return "XGL_SLOT_UNUSED";
+
+ }
+ return "Unhandled XGL_DESCRIPTOR_SET_SLOT_TYPE";
+}
+
+
+static const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+{
+ switch ((XGL_TEX_ADDRESS)input_value)
+ {
+
+ case XGL_TEX_ADDRESS_CLAMP:
+ return "XGL_TEX_ADDRESS_CLAMP";
+
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+
+ case XGL_TEX_ADDRESS_MIRROR:
+ return "XGL_TEX_ADDRESS_MIRROR";
+
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+
+ case XGL_TEX_ADDRESS_WRAP:
+ return "XGL_TEX_ADDRESS_WRAP";
+
+ }
+ return "Unhandled XGL_TEX_ADDRESS";
+}
+
+
+static const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+{
+ switch ((XGL_QUERY_TYPE)input_value)
+ {
+
+ case XGL_QUERY_OCCLUSION:
+ return "XGL_QUERY_OCCLUSION";
+
+ case XGL_QUERY_PIPELINE_STATISTICS:
+ return "XGL_QUERY_PIPELINE_STATISTICS";
+
+ }
+ return "Unhandled XGL_QUERY_TYPE";
+}
+
+
+static const char* string_XGL_ATOMIC_OP(XGL_ATOMIC_OP input_value)
+{
+ switch ((XGL_ATOMIC_OP)input_value)
+ {
+
+ case XGL_ATOMIC_ADD_INT32:
+ return "XGL_ATOMIC_ADD_INT32";
+
+ case XGL_ATOMIC_ADD_INT64:
+ return "XGL_ATOMIC_ADD_INT64";
+
+ case XGL_ATOMIC_AND_INT32:
+ return "XGL_ATOMIC_AND_INT32";
+
+ case XGL_ATOMIC_AND_INT64:
+ return "XGL_ATOMIC_AND_INT64";
+
+ case XGL_ATOMIC_DEC_UINT32:
+ return "XGL_ATOMIC_DEC_UINT32";
+
+ case XGL_ATOMIC_DEC_UINT64:
+ return "XGL_ATOMIC_DEC_UINT64";
+
+ case XGL_ATOMIC_INC_UINT32:
+ return "XGL_ATOMIC_INC_UINT32";
+
+ case XGL_ATOMIC_INC_UINT64:
+ return "XGL_ATOMIC_INC_UINT64";
+
+ case XGL_ATOMIC_MAX_SINT32:
+ return "XGL_ATOMIC_MAX_SINT32";
+
+ case XGL_ATOMIC_MAX_SINT64:
+ return "XGL_ATOMIC_MAX_SINT64";
+
+ case XGL_ATOMIC_MAX_UINT32:
+ return "XGL_ATOMIC_MAX_UINT32";
+
+ case XGL_ATOMIC_MAX_UINT64:
+ return "XGL_ATOMIC_MAX_UINT64";
+
+ case XGL_ATOMIC_MIN_SINT32:
+ return "XGL_ATOMIC_MIN_SINT32";
+
+ case XGL_ATOMIC_MIN_SINT64:
+ return "XGL_ATOMIC_MIN_SINT64";
+
+ case XGL_ATOMIC_MIN_UINT32:
+ return "XGL_ATOMIC_MIN_UINT32";
+
+ case XGL_ATOMIC_MIN_UINT64:
+ return "XGL_ATOMIC_MIN_UINT64";
+
+ case XGL_ATOMIC_OR_INT32:
+ return "XGL_ATOMIC_OR_INT32";
+
+ case XGL_ATOMIC_OR_INT64:
+ return "XGL_ATOMIC_OR_INT64";
+
+ case XGL_ATOMIC_SUB_INT32:
+ return "XGL_ATOMIC_SUB_INT32";
+
+ case XGL_ATOMIC_SUB_INT64:
+ return "XGL_ATOMIC_SUB_INT64";
+
+ case XGL_ATOMIC_XOR_INT32:
+ return "XGL_ATOMIC_XOR_INT32";
+
+ case XGL_ATOMIC_XOR_INT64:
+ return "XGL_ATOMIC_XOR_INT64";
+
+ }
+ return "Unhandled XGL_ATOMIC_OP";
+}
+
+
+static const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+
+ case XGL_PROVOKING_VERTEX_FIRST:
+ return "XGL_PROVOKING_VERTEX_FIRST";
+
+ case XGL_PROVOKING_VERTEX_LAST:
+ return "XGL_PROVOKING_VERTEX_LAST";
+
+ }
+ return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+}
+
+
+static const char* string_XGL_MEMORY_HEAP_INFO_TYPE(XGL_MEMORY_HEAP_INFO_TYPE input_value)
+{
+ switch ((XGL_MEMORY_HEAP_INFO_TYPE)input_value)
+ {
+
+ case XGL_INFO_TYPE_MEMORY_HEAP_PROPERTIES:
+ return "XGL_INFO_TYPE_MEMORY_HEAP_PROPERTIES";
+
+ }
+ return "Unhandled XGL_MEMORY_HEAP_INFO_TYPE";
+}
+
+
+static const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ {
+
+ case XGL_TOPOLOGY_LINE_LIST:
+ return "XGL_TOPOLOGY_LINE_LIST";
+
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+
+ case XGL_TOPOLOGY_LINE_STRIP:
+ return "XGL_TOPOLOGY_LINE_STRIP";
+
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+
+ case XGL_TOPOLOGY_PATCH:
+ return "XGL_TOPOLOGY_PATCH";
+
+ case XGL_TOPOLOGY_POINT_LIST:
+ return "XGL_TOPOLOGY_POINT_LIST";
+
+ case XGL_TOPOLOGY_QUAD_LIST:
+ return "XGL_TOPOLOGY_QUAD_LIST";
+
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ return "XGL_TOPOLOGY_QUAD_STRIP";
+
+ case XGL_TOPOLOGY_RECT_LIST:
+ return "XGL_TOPOLOGY_RECT_LIST";
+
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST";
+
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+
+ }
+ return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+}
+
+
+static const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+ switch ((XGL_BLEND_FUNC)input_value)
+ {
+
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
+
+ }
+ return "Unhandled XGL_BLEND_FUNC";
+}
+
+
+static const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+{
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ {
+
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+
+ }
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+}
+
+
+static const char* string_XGL_MEMORY_STATE(XGL_MEMORY_STATE input_value)
+{
+ switch ((XGL_MEMORY_STATE)input_value)
+ {
+
+ case XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY:
+ return "XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY";
+
+ case XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE:
+ return "XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE";
+
+ case XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY:
+ return "XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY";
+
+ case XGL_MEMORY_STATE_DATA_TRANSFER:
+ return "XGL_MEMORY_STATE_DATA_TRANSFER";
+
+ case XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY:
+ return "XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY";
+
+ case XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE:
+ return "XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE";
+
+ case XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY:
+ return "XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY";
+
+ case XGL_MEMORY_STATE_INDEX_DATA:
+ return "XGL_MEMORY_STATE_INDEX_DATA";
+
+ case XGL_MEMORY_STATE_INDIRECT_ARG:
+ return "XGL_MEMORY_STATE_INDIRECT_ARG";
+
+ case XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY:
+ return "XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY";
+
+ case XGL_MEMORY_STATE_QUEUE_ATOMIC:
+ return "XGL_MEMORY_STATE_QUEUE_ATOMIC";
+
+ case XGL_MEMORY_STATE_WRITE_TIMESTAMP:
+ return "XGL_MEMORY_STATE_WRITE_TIMESTAMP";
+
+ }
+ return "Unhandled XGL_MEMORY_STATE";
+}
+
+
+static const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
+
+ }
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+}
+
+
+static const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+
+ }
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
+}
+
+
+static const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+{
+ switch ((XGL_STATE_BIND_POINT)input_value)
+ {
+
+ case XGL_STATE_BIND_COLOR_BLEND:
+ return "XGL_STATE_BIND_COLOR_BLEND";
+
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ return "XGL_STATE_BIND_DEPTH_STENCIL";
+
+ case XGL_STATE_BIND_MSAA:
+ return "XGL_STATE_BIND_MSAA";
+
+ case XGL_STATE_BIND_RASTER:
+ return "XGL_STATE_BIND_RASTER";
+
+ case XGL_STATE_BIND_VIEWPORT:
+ return "XGL_STATE_BIND_VIEWPORT";
+
+ }
+ return "Unhandled XGL_STATE_BIND_POINT";
+}
+
+
+static const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ {
+
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+
+ }
+ return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+}
+
+
+static const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ {
+
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
+
+ }
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
+}
+
+
+static const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+{
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
+ {
+
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
+
+ }
+ return "Unhandled XGL_TIMESTAMP_TYPE";
+}
+
+
+static const char* string_XGL_MEMORY_HEAP_FLAGS(XGL_MEMORY_HEAP_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_HEAP_FLAGS)input_value)
+ {
+
+ case XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT:
+ return "XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT";
+
+ case XGL_MEMORY_HEAP_CPU_UNCACHED_BIT:
+ return "XGL_MEMORY_HEAP_CPU_UNCACHED_BIT";
+
+ case XGL_MEMORY_HEAP_CPU_VISIBLE_BIT:
+ return "XGL_MEMORY_HEAP_CPU_VISIBLE_BIT";
+
+ case XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT:
+ return "XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT";
+
+ case XGL_MEMORY_HEAP_HOLDS_PINNED_BIT:
+ return "XGL_MEMORY_HEAP_HOLDS_PINNED_BIT";
+
+ case XGL_MEMORY_HEAP_SHAREABLE_BIT:
+ return "XGL_MEMORY_HEAP_SHAREABLE_BIT";
+
+ }
+ return "Unhandled XGL_MEMORY_HEAP_FLAGS";
+}
+
+
+static const char* string_XGL_MEMORY_ALLOC_FLAGS(XGL_MEMORY_ALLOC_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_ALLOC_FLAGS)input_value)
+ {
+
+ case XGL_MEMORY_ALLOC_SHAREABLE_BIT:
+ return "XGL_MEMORY_ALLOC_SHAREABLE_BIT";
+
+ case XGL_MEMORY_ALLOC_VIRTUAL_BIT:
+ return "XGL_MEMORY_ALLOC_VIRTUAL_BIT";
+
+ }
+ return "Unhandled XGL_MEMORY_ALLOC_FLAGS";
+}
+
+
+static const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
+
+ }
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+}
+
+
+static const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ {
+
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+
+ }
+ return "Unhandled XGL_BORDER_COLOR_TYPE";
+}
+
+
+static const char* string_XGL_IMAGE_STATE(XGL_IMAGE_STATE input_value)
+{
+ switch ((XGL_IMAGE_STATE)input_value)
+ {
+
+ case XGL_IMAGE_STATE_CLEAR:
+ return "XGL_IMAGE_STATE_CLEAR";
+
+ case XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY:
+ return "XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY";
+
+ case XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE:
+ return "XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE";
+
+ case XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY:
+ return "XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY";
+
+ case XGL_IMAGE_STATE_DATA_TRANSFER:
+ return "XGL_IMAGE_STATE_DATA_TRANSFER";
+
+ case XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY:
+ return "XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY";
+
+ case XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE:
+ return "XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE";
+
+ case XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY:
+ return "XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY";
+
+ case XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY:
+ return "XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY";
+
+ case XGL_IMAGE_STATE_RESOLVE_DESTINATION:
+ return "XGL_IMAGE_STATE_RESOLVE_DESTINATION";
+
+ case XGL_IMAGE_STATE_RESOLVE_SOURCE:
+ return "XGL_IMAGE_STATE_RESOLVE_SOURCE";
+
+ case XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY:
+ return "XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY";
+
+ case XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL:
+ return "XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL";
+
+ case XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL:
+ return "XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL";
+
+ case XGL_IMAGE_STATE_UNINITIALIZED_TARGET:
+ return "XGL_IMAGE_STATE_UNINITIALIZED_TARGET";
+
+ }
+ return "Unhandled XGL_IMAGE_STATE";
+}
+
+
+static const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ {
+
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
+
+ }
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
+}
+
+
+static const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+ switch ((XGL_LOGIC_OP)input_value)
+ {
+
+ case XGL_LOGIC_OP_AND:
+ return "XGL_LOGIC_OP_AND";
+
+ case XGL_LOGIC_OP_AND_INVERTED:
+ return "XGL_LOGIC_OP_AND_INVERTED";
+
+ case XGL_LOGIC_OP_AND_REVERSE:
+ return "XGL_LOGIC_OP_AND_REVERSE";
+
+ case XGL_LOGIC_OP_CLEAR:
+ return "XGL_LOGIC_OP_CLEAR";
+
+ case XGL_LOGIC_OP_COPY:
+ return "XGL_LOGIC_OP_COPY";
+
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ return "XGL_LOGIC_OP_COPY_INVERTED";
+
+ case XGL_LOGIC_OP_EQUIV:
+ return "XGL_LOGIC_OP_EQUIV";
+
+ case XGL_LOGIC_OP_INVERT:
+ return "XGL_LOGIC_OP_INVERT";
+
+ case XGL_LOGIC_OP_NAND:
+ return "XGL_LOGIC_OP_NAND";
+
+ case XGL_LOGIC_OP_NOOP:
+ return "XGL_LOGIC_OP_NOOP";
+
+ case XGL_LOGIC_OP_NOR:
+ return "XGL_LOGIC_OP_NOR";
+
+ case XGL_LOGIC_OP_OR:
+ return "XGL_LOGIC_OP_OR";
+
+ case XGL_LOGIC_OP_OR_INVERTED:
+ return "XGL_LOGIC_OP_OR_INVERTED";
+
+ case XGL_LOGIC_OP_OR_REVERSE:
+ return "XGL_LOGIC_OP_OR_REVERSE";
+
+ case XGL_LOGIC_OP_SET:
+ return "XGL_LOGIC_OP_SET";
+
+ case XGL_LOGIC_OP_XOR:
+ return "XGL_LOGIC_OP_XOR";
+
+ }
+ return "Unhandled XGL_LOGIC_OP";
+}
+
+
+static const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+{
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+ {
+
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
+
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
+
+ case XGL_FORMAT_CONVERSION_BIT:
+ return "XGL_FORMAT_CONVERSION_BIT";
+
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
+
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ return "XGL_FORMAT_IMAGE_COPY_BIT";
+
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
+
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
+
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
+
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
+
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
+
+ }
+ return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
+}
+
+
+static const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+{
+ switch ((XGL_VALIDATION_LEVEL)input_value)
+ {
+
+ case XGL_VALIDATION_LEVEL_0:
+ return "XGL_VALIDATION_LEVEL_0";
+
+ case XGL_VALIDATION_LEVEL_1:
+ return "XGL_VALIDATION_LEVEL_1";
+
+ case XGL_VALIDATION_LEVEL_2:
+ return "XGL_VALIDATION_LEVEL_2";
+
+ case XGL_VALIDATION_LEVEL_3:
+ return "XGL_VALIDATION_LEVEL_3";
+
+ case XGL_VALIDATION_LEVEL_4:
+ return "XGL_VALIDATION_LEVEL_4";
+
+ }
+ return "Unhandled XGL_VALIDATION_LEVEL";
+}
+
+
+static const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
+
+ }
+ return "Unhandled XGL_CULL_MODE";
+}
+
+
+static const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ {
+
+ case XGL_SHADER_STAGE_COMPUTE:
+ return "XGL_SHADER_STAGE_COMPUTE";
+
+ case XGL_SHADER_STAGE_FRAGMENT:
+ return "XGL_SHADER_STAGE_FRAGMENT";
+
+ case XGL_SHADER_STAGE_GEOMETRY:
+ return "XGL_SHADER_STAGE_GEOMETRY";
+
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ return "XGL_SHADER_STAGE_TESS_CONTROL";
+
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ return "XGL_SHADER_STAGE_TESS_EVALUATION";
+
+ case XGL_SHADER_STAGE_VERTEX:
+ return "XGL_SHADER_STAGE_VERTEX";
+
+ }
+ return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+}
+
+
+static const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ {
+
+ case XGL_CHANNEL_SWIZZLE_A:
+ return "XGL_CHANNEL_SWIZZLE_A";
+
+ case XGL_CHANNEL_SWIZZLE_B:
+ return "XGL_CHANNEL_SWIZZLE_B";
+
+ case XGL_CHANNEL_SWIZZLE_G:
+ return "XGL_CHANNEL_SWIZZLE_G";
+
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ return "XGL_CHANNEL_SWIZZLE_ONE";
+
+ case XGL_CHANNEL_SWIZZLE_R:
+ return "XGL_CHANNEL_SWIZZLE_R";
+
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return "XGL_CHANNEL_SWIZZLE_ZERO";
+
+ }
+ return "Unhandled XGL_CHANNEL_SWIZZLE";
+}
+
+
+static const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+
+ }
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+}
+
+
+static const char* string_XGL_RESULT(XGL_RESULT input_value)
+{
+ switch ((XGL_RESULT)input_value)
+ {
+
+ case XGL_EVENT_RESET:
+ return "XGL_EVENT_RESET";
+
+ case XGL_EVENT_SET:
+ return "XGL_EVENT_SET";
+
+ case XGL_NOT_READY:
+ return "XGL_NOT_READY";
+
+ case XGL_SUCCESS:
+ return "XGL_SUCCESS";
+
+ case XGL_TIMEOUT:
+ return "XGL_TIMEOUT";
+
+ case XGL_UNSUPPORTED:
+ return "XGL_UNSUPPORTED";
+
+ }
+ return "Unhandled XGL_RESULT";
+}
+
+
+static const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ {
+
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+
+ }
+ return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
+}
+
+
+static const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ {
+
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+
+ }
+ return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+}
+
+
+static const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+
+ case XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION:
+ return "XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION";
+
+ case XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO";
+
+ case XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
+
+ case XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO";
+
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+
+ }
+ return "Unhandled XGL_STRUCTURE_TYPE";
+}
+
+
+static const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ {
+
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
+
+ }
+ return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+}
+
+
+static const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+{
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ {
+
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+
+ }
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+}
+
+
+static const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+
+ case XFL_FILL_POINTS:
+ return "XFL_FILL_POINTS";
+
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
+
+ }
+ return "Unhandled XGL_FILL_MODE";
+}
+
+
+static const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+{
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+ {
+
+ case XGL_IMAGE_VIEW_1D:
+ return "XGL_IMAGE_VIEW_1D";
+
+ case XGL_IMAGE_VIEW_2D:
+ return "XGL_IMAGE_VIEW_2D";
+
+ case XGL_IMAGE_VIEW_3D:
+ return "XGL_IMAGE_VIEW_3D";
+
+ case XGL_IMAGE_VIEW_CUBE:
+ return "XGL_IMAGE_VIEW_CUBE";
+
+ }
+ return "Unhandled XGL_IMAGE_VIEW_TYPE";
+}
+
+
+static const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
+
+ }
+ return "Unhandled XGL_IMAGE_TYPE";
+}
+
+
+static const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+
+ case XGL_INDEX_16:
+ return "XGL_INDEX_16";
+
+ case XGL_INDEX_32:
+ return "XGL_INDEX_32";
+
+ case XGL_INDEX_8:
+ return "XGL_INDEX_8";
+
+ }
+ return "Unhandled XGL_INDEX_TYPE";
+}
+
+
+static const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+
+ }
+ return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+}
+
+
+static const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
+
+ }
+ return "Unhandled XGL_QUEUE_TYPE";
+}
+
+
+static const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
+
+ }
+ return "Unhandled XGL_STENCIL_OP";
+}
+
+
+static const char* string_XGL_CHANNEL_FORMAT(XGL_CHANNEL_FORMAT input_value)
+{
+ switch ((XGL_CHANNEL_FORMAT)input_value)
+ {
+
+ case XGL_CH_FMT_B5G6R5:
+ return "XGL_CH_FMT_B5G6R5";
+
+ case XGL_CH_FMT_B8G8R8A8:
+ return "XGL_CH_FMT_B8G8R8A8";
+
+ case XGL_CH_FMT_BC1:
+ return "XGL_CH_FMT_BC1";
+
+ case XGL_CH_FMT_BC2:
+ return "XGL_CH_FMT_BC2";
+
+ case XGL_CH_FMT_BC3:
+ return "XGL_CH_FMT_BC3";
+
+ case XGL_CH_FMT_BC4:
+ return "XGL_CH_FMT_BC4";
+
+ case XGL_CH_FMT_BC5:
+ return "XGL_CH_FMT_BC5";
+
+ case XGL_CH_FMT_BC6S:
+ return "XGL_CH_FMT_BC6S";
+
+ case XGL_CH_FMT_BC6U:
+ return "XGL_CH_FMT_BC6U";
+
+ case XGL_CH_FMT_BC7:
+ return "XGL_CH_FMT_BC7";
+
+ case XGL_CH_FMT_R10G10B10A2:
+ return "XGL_CH_FMT_R10G10B10A2";
+
+ case XGL_CH_FMT_R10G11B11:
+ return "XGL_CH_FMT_R10G11B11";
+
+ case XGL_CH_FMT_R11G11B10:
+ return "XGL_CH_FMT_R11G11B10";
+
+ case XGL_CH_FMT_R16:
+ return "XGL_CH_FMT_R16";
+
+ case XGL_CH_FMT_R16G16:
+ return "XGL_CH_FMT_R16G16";
+
+ case XGL_CH_FMT_R16G16B16A16:
+ return "XGL_CH_FMT_R16G16B16A16";
+
+ case XGL_CH_FMT_R16G8:
+ return "XGL_CH_FMT_R16G8";
+
+ case XGL_CH_FMT_R32:
+ return "XGL_CH_FMT_R32";
+
+ case XGL_CH_FMT_R32G32:
+ return "XGL_CH_FMT_R32G32";
+
+ case XGL_CH_FMT_R32G32B32:
+ return "XGL_CH_FMT_R32G32B32";
+
+ case XGL_CH_FMT_R32G32B32A32:
+ return "XGL_CH_FMT_R32G32B32A32";
+
+ case XGL_CH_FMT_R32G8:
+ return "XGL_CH_FMT_R32G8";
+
+ case XGL_CH_FMT_R4G4:
+ return "XGL_CH_FMT_R4G4";
+
+ case XGL_CH_FMT_R4G4B4A4:
+ return "XGL_CH_FMT_R4G4B4A4";
+
+ case XGL_CH_FMT_R5G5B5A1:
+ return "XGL_CH_FMT_R5G5B5A1";
+
+ case XGL_CH_FMT_R5G6B5:
+ return "XGL_CH_FMT_R5G6B5";
+
+ case XGL_CH_FMT_R8:
+ return "XGL_CH_FMT_R8";
+
+ case XGL_CH_FMT_R8G8:
+ return "XGL_CH_FMT_R8G8";
+
+ case XGL_CH_FMT_R8G8B8A8:
+ return "XGL_CH_FMT_R8G8B8A8";
+
+ case XGL_CH_FMT_R9G9B9E5:
+ return "XGL_CH_FMT_R9G9B9E5";
+
+ case XGL_CH_FMT_UNDEFINED:
+ return "XGL_CH_FMT_UNDEFINED";
+
+ }
+ return "Unhandled XGL_CHANNEL_FORMAT";
+}
+
+
+static const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+
+ case XGL_COMPARE_ALWAYS:
+ return "XGL_COMPARE_ALWAYS";
+
+ case XGL_COMPARE_EQUAL:
+ return "XGL_COMPARE_EQUAL";
+
+ case XGL_COMPARE_GREATER:
+ return "XGL_COMPARE_GREATER";
+
+ case XGL_COMPARE_GREATER_EQUAL:
+ return "XGL_COMPARE_GREATER_EQUAL";
+
+ case XGL_COMPARE_LESS:
+ return "XGL_COMPARE_LESS";
+
+ case XGL_COMPARE_LESS_EQUAL:
+ return "XGL_COMPARE_LESS_EQUAL";
+
+ case XGL_COMPARE_NEVER:
+ return "XGL_COMPARE_NEVER";
+
+ case XGL_COMPARE_NOT_EQUAL:
+ return "XGL_COMPARE_NOT_EQUAL";
+
+ }
+ return "Unhandled XGL_COMPARE_FUNC";
+}
+
+
+static const char* string_XGL_HEAP_MEMORY_TYPE(XGL_HEAP_MEMORY_TYPE input_value)
+{
+ switch ((XGL_HEAP_MEMORY_TYPE)input_value)
+ {
+
+ case XGL_HEAP_MEMORY_EMBEDDED:
+ return "XGL_HEAP_MEMORY_EMBEDDED";
+
+ case XGL_HEAP_MEMORY_LOCAL:
+ return "XGL_HEAP_MEMORY_LOCAL";
+
+ case XGL_HEAP_MEMORY_OTHER:
+ return "XGL_HEAP_MEMORY_OTHER";
+
+ case XGL_HEAP_MEMORY_REMOTE:
+ return "XGL_HEAP_MEMORY_REMOTE";
+
+ }
+ return "Unhandled XGL_HEAP_MEMORY_TYPE";
+}
+
+
+static const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ {
+
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+
+ }
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
+}
+
+
+static const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+ switch ((XGL_IMAGE_TILING)input_value)
+ {
+
+ case XGL_LINEAR_TILING:
+ return "XGL_LINEAR_TILING";
+
+ case XGL_OPTIMAL_TILING:
+ return "XGL_OPTIMAL_TILING";
+
+ }
+ return "Unhandled XGL_IMAGE_TILING";
+}
+
+
+static const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ {
+
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
+
+ }
+ return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+}
+
+
+static const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
+
+ }
+ return "Unhandled XGL_FACE_ORIENTATION";
+}
+
+
+static const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+ switch ((XGL_QUEUE_FLAGS)input_value)
+ {
+
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
+
+ }
+ return "Unhandled XGL_QUEUE_FLAGS";
+}
+
+
+static const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+{
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ {
+
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
+
+ }
+ return "Unhandled XGL_PIPELINE_BIND_POINT";
+}
+
+
+static const char* string_XGL_BLEND(XGL_BLEND input_value)
+{
+ switch ((XGL_BLEND)input_value)
+ {
+
+ case XGL_BLEND_CONSTANT_ALPHA:
+ return "XGL_BLEND_CONSTANT_ALPHA";
+
+ case XGL_BLEND_CONSTANT_COLOR:
+ return "XGL_BLEND_CONSTANT_COLOR";
+
+ case XGL_BLEND_DEST_ALPHA:
+ return "XGL_BLEND_DEST_ALPHA";
+
+ case XGL_BLEND_DEST_COLOR:
+ return "XGL_BLEND_DEST_COLOR";
+
+ case XGL_BLEND_ONE:
+ return "XGL_BLEND_ONE";
+
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
+
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
+
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
+
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
+
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
+
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
+
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
+
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
+
+ case XGL_BLEND_SRC1_ALPHA:
+ return "XGL_BLEND_SRC1_ALPHA";
+
+ case XGL_BLEND_SRC1_COLOR:
+ return "XGL_BLEND_SRC1_COLOR";
+
+ case XGL_BLEND_SRC_ALPHA:
+ return "XGL_BLEND_SRC_ALPHA";
+
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ return "XGL_BLEND_SRC_ALPHA_SATURATE";
+
+ case XGL_BLEND_SRC_COLOR:
+ return "XGL_BLEND_SRC_COLOR";
+
+ case XGL_BLEND_ZERO:
+ return "XGL_BLEND_ZERO";
+
+ }
+ return "Unhandled XGL_BLEND";
+}
+
diff --git a/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_string_helper.h b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_string_helper.h
new file mode 100644
index 0000000..833c840
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_string_helper.h
@@ -0,0 +1,553 @@
+//This is the copyright
+//#includes, #defines, globals and such...
+#include <xgl.h>
+#include <xgl_string_helper.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+char* xgl_print_xgl_raster_state_create_info(const XGL_RASTER_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n%sdepthBias = %i\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias));
+ return str;
+}
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ return str;
+}
+char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sviewType = %s\n%sformat = %p\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, (void*)&(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod));
+ return str;
+}
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
+ return str;
+}
+char* xgl_print_xgl_memory_heap_properties(const XGL_MEMORY_HEAP_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sstructSize = %u\n%sheapMemoryType = %s\n%sheapSize = %u\n%spageSize = %u\n%sflags = %u\n%sgpuReadPerfRating = %f\n%sgpuWritePerfRating = %f\n%scpuReadPerfRating = %f\n%scpuWritePerfRating = %f\n", prefix, (pStruct->structSize), prefix, string_XGL_HEAP_MEMORY_TYPE(pStruct->heapMemoryType), prefix, (pStruct->heapSize), prefix, (pStruct->pageSize), prefix, (pStruct->flags), prefix, (pStruct->gpuReadPerfRating), prefix, (pStruct->gpuWritePerfRating), prefix, (pStruct->cpuReadPerfRating), prefix, (pStruct->cpuWritePerfRating));
+ return str;
+}
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sstructSize = %u\n%ssupportsMigration = %s\n%ssupportsVirtualMemoryRemapping = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->structSize), prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsVirtualMemoryRemapping) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sstage = %s\n%sshader = %p\n%sdescriptorSetMapping = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n%sdynamicMemoryViewMapping = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (void*)(pStruct->descriptorSetMapping), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo), prefix, (void*)&(pStruct->dynamicMemoryViewMapping));
+ return str;
+}
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sblendEnable = %s\n%sformat = %p\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, (void*)&(pStruct->format), prefix, (pStruct->channelWriteMask));
+ return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
+ return str;
+}
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (void*)&(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
+ return str;
+}
+char* xgl_print_xgl_image_copy(const XGL_IMAGE_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
+ return str;
+}
+char* xgl_print_xgl_msaa_state_create_info(const XGL_MSAA_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%ssamples = %u\n%ssampleMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->samples), prefix, (pStruct->sampleMask));
+ return str;
+}
+char* xgl_print_xgl_descriptor_set_create_info(const XGL_DESCRIPTOR_SET_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->slots));
+ return str;
+}
+char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sview = %p\n%scolorAttachmentState = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->colorAttachmentState));
+ return str;
+}
+char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssize = %u\n%salignment = %u\n%sheapCount = %u\n%sheaps = %p\n", prefix, (pStruct->size), prefix, (pStruct->alignment), prefix, (pStruct->heapCount), prefix, (void*)(pStruct->heaps));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
+ return str;
+}
+char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
+ return str;
+}
+char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
+ return str;
+}
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sstructSize = %u\n%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->structSize), prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
+ return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+ return str;
+}
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+ return str;
+}
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_format(const XGL_FORMAT* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%schannelFormat = %s\n%snumericFormat = %s\n", prefix, string_XGL_CHANNEL_FORMAT(pStruct->channelFormat), prefix, string_XGL_NUM_FORMAT(pStruct->numericFormat));
+ return str;
+}
+char* xgl_print_xgl_memory_state_transition(const XGL_MEMORY_STATE_TRANSITION* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%smem = %p\n%soldState = %s\n%snewState = %s\n%soffset = %u\n%sregionSize = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->mem), prefix, string_XGL_MEMORY_STATE(pStruct->oldState), prefix, string_XGL_MEMORY_STATE(pStruct->newState), prefix, (pStruct->offset), prefix, (pStruct->regionSize));
+ return str;
+}
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
+ return str;
+}
+char* xgl_print_xgl_dynamic_memory_view_slot_info(const XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sslotObjectType = %s\n%sshaderEntityIndex = %u\n", prefix, string_XGL_DESCRIPTOR_SET_SLOT_TYPE(pStruct->slotObjectType), prefix, (pStruct->shaderEntityIndex));
+ return str;
+}
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sview = %p\n%sstate = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->state));
+ return str;
+}
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
+ return str;
+}
+char* xgl_print_xgl_pipeline_db_state_create_info(const XGL_PIPELINE_DB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sformat = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->format));
+ return str;
+}
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
+ return str;
+}
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+ return str;
+}
+char* xgl_print_xgl_viewport_state_create_info(const XGL_VIEWPORT_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sviewportCount = %u\n%sscissorEnable = %s\n%sviewports = %p\n%sscissors = %p\n", prefix, (pStruct->viewportCount), prefix, (pStruct->scissorEnable) ? "TRUE" : "FALSE", prefix, (void*)(pStruct->viewports), prefix, (void*)(pStruct->scissors));
+ return str;
+}
+char* xgl_print_xgl_image_state_transition(const XGL_IMAGE_STATE_TRANSITION* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%simage = %p\n%soldState = %s\n%snewState = %s\n%ssubresourceRange = %p\n", prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_STATE(pStruct->oldState), prefix, string_XGL_IMAGE_STATE(pStruct->newState), prefix, (void*)&(pStruct->subresourceRange));
+ return str;
+}
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %p\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames), prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %p\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, (void*)&(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
+ return str;
+}
+char* xgl_print_xgl_memory_copy(const XGL_MEMORY_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssrcOffset = %u\n%sdestOffset = %u\n%scopySize = %u\n", prefix, (pStruct->srcOffset), prefix, (pStruct->destOffset), prefix, (pStruct->copySize));
+ return str;
+}
+char* xgl_print_xgl_descriptor_slot_info(const XGL_DESCRIPTOR_SLOT_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sslotObjectType = %s\n%sshaderEntityIndex = %u\n%spNextLevelSet = %p\n", prefix, string_XGL_DESCRIPTOR_SET_SLOT_TYPE(pStruct->slotObjectType), prefix, (pStruct->shaderEntityIndex), prefix, (pStruct->pNextLevelSet));
+ return str;
+}
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sbufferId = %u\n%sbufferSize = %u\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (pStruct->bufferSize), prefix, (pStruct->pBufferData));
+ return str;
+}
+char* xgl_print_xgl_memory_image_copy(const XGL_MEMORY_IMAGE_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%smemOffset = %u\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (pStruct->memOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_state_create_info(const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilTestEnable = %s\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sfront = %p\n%sback = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back));
+ return str;
+}
+char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
+ return str;
+}
+char* xgl_print_xgl_descriptor_set_mapping(const XGL_DESCRIPTOR_SET_MAPPING* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sdescriptorCount = %u\n%spDescriptorInfo = %p\n", prefix, (pStruct->descriptorCount), prefix, (void*)(pStruct->pDescriptorInfo));
+ return str;
+}
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
+ return str;
+}
+char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%soffset = %u\n%ssize = %u\n%srowPitch = %u\n%sdepthPitch = %u\n", prefix, (pStruct->offset), prefix, (pStruct->size), prefix, (pStruct->rowPitch), prefix, (pStruct->depthPitch));
+ return str;
+}
+char* xgl_print_xgl_descriptor_set_attach_info(const XGL_DESCRIPTOR_SET_ATTACH_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sdescriptorSet = %p\n%sslotOffset = %u\n", prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->slotOffset));
+ return str;
+}
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+ return str;
+}
+char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%spointSize = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->pointSize));
+ return str;
+}
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n%sstencilRef = %u\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc), prefix, (pStruct->stencilRef));
+ return str;
+}
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%scodeSize = %u\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_color_blend_state_create_info(const XGL_COLOR_BLEND_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sattachment = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->attachment), prefix, (void*)(pStruct->blendConst));
+ return str;
+}
+char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%sdualSourceBlendEnable = %s\n%slogicOp = %s\n%sattachment = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->dualSourceBlendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (void*)(pStruct->attachment));
+ return str;
+}
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_virtual_memory_remap_range(const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%svirtualMem = %p\n%svirtualStartPage = %u\n%srealMem = %p\n%srealStartPage = %u\n%spageCount = %u\n", prefix, (void*)(pStruct->virtualMem), prefix, (pStruct->virtualStartPage), prefix, (void*)(pStruct->realMem), prefix, (pStruct->realStartPage), prefix, (pStruct->pageCount));
+ return str;
+}
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sstructSize = %u\n%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%svirtualMemPageSize = %u\n%smaxInlineMemoryUpdateSize = %u\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n", prefix, (pStruct->structSize), prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (pStruct->virtualMemPageSize), prefix, (pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE");
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sview = %p\n%sdepthState = %s\n%sstencilState = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_STATE(pStruct->depthState), prefix, string_XGL_IMAGE_STATE(pStruct->stencilState));
+ return str;
+}
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ return str;
+}
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprovokingVertex = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
+ return str;
+}
+char* xgl_print_xgl_color_attachment_blend_state(const XGL_COLOR_ATTACHMENT_BLEND_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sblendEnable = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha));
+ return str;
+}
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
+ return str;
+}
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sallocationSize = %u\n%salignment = %u\n%sflags = %u\n%sheapCount = %u\n%sheaps = %p\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->allocationSize), prefix, (pStruct->alignment), prefix, (pStruct->flags), prefix, (pStruct->heapCount), prefix, (void*)(pStruct->heaps), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
+ return str;
+}
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
+ return str;
+}
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
+ return str;
+}
+char* xgl_print_xgl_memory_view_attach_info(const XGL_MEMORY_VIEW_ATTACH_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%ssType = %s\n%spNext = %p\n%smem = %p\n%soffset = %u\n%srange = %u\n%sstride = %u\n%sformat = %p\n%sstate = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->mem), prefix, (pStruct->offset), prefix, (pStruct->range), prefix, (pStruct->stride), prefix, (void*)&(pStruct->format), prefix, string_XGL_MEMORY_STATE(pStruct->state));
+ return str;
+}
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ str = (char*)malloc(sizeof(char)*1024);
+ sprintf(str, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ return str;
+}
diff --git a/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_wrappers.cpp b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_wrappers.cpp
new file mode 100644
index 0000000..3bf712b
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_wrappers.cpp
@@ -0,0 +1,3974 @@
+//This is the copyright
+//#includes, #defines, globals and such...
+#include <stdio.h>
+#include <xgl_struct_wrappers.h>
+#include <xgl_string_helper.h>
+
+void dynamic_display_full_txt(const XGL_VOID* pStruct, uint32_t indent)
+{
+ // Cast to APP_INFO ptr initially just to pull sType off struct
+ XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType; switch (sType)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ {
+ xgl_application_info_struct_wrapper swc0((XGL_APPLICATION_INFO*)pStruct);
+ swc0.set_indent(indent);
+ swc0.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ {
+ xgl_cmd_buffer_create_info_struct_wrapper swc1((XGL_CMD_BUFFER_CREATE_INFO*)pStruct);
+ swc1.set_indent(indent);
+ swc1.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ {
+ xgl_color_attachment_view_create_info_struct_wrapper swc2((XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO*)pStruct);
+ swc2.set_indent(indent);
+ swc2.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO:
+ {
+ xgl_color_blend_state_create_info_struct_wrapper swc3((XGL_COLOR_BLEND_STATE_CREATE_INFO*)pStruct);
+ swc3.set_indent(indent);
+ swc3.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ {
+ xgl_compute_pipeline_create_info_struct_wrapper swc4((XGL_COMPUTE_PIPELINE_CREATE_INFO*)pStruct);
+ swc4.set_indent(indent);
+ swc4.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO:
+ {
+ xgl_depth_stencil_state_create_info_struct_wrapper swc5((XGL_DEPTH_STENCIL_STATE_CREATE_INFO*)pStruct);
+ swc5.set_indent(indent);
+ swc5.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ {
+ xgl_depth_stencil_view_create_info_struct_wrapper swc6((XGL_DEPTH_STENCIL_VIEW_CREATE_INFO*)pStruct);
+ swc6.set_indent(indent);
+ swc6.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO:
+ {
+ xgl_descriptor_set_create_info_struct_wrapper swc7((XGL_DESCRIPTOR_SET_CREATE_INFO*)pStruct);
+ swc7.set_indent(indent);
+ swc7.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ {
+ xgl_device_create_info_struct_wrapper swc8((XGL_DEVICE_CREATE_INFO*)pStruct);
+ swc8.set_indent(indent);
+ swc8.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ {
+ xgl_event_create_info_struct_wrapper swc9((XGL_EVENT_CREATE_INFO*)pStruct);
+ swc9.set_indent(indent);
+ swc9.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ {
+ xgl_fence_create_info_struct_wrapper swc10((XGL_FENCE_CREATE_INFO*)pStruct);
+ swc10.set_indent(indent);
+ swc10.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ {
+ xgl_graphics_pipeline_create_info_struct_wrapper swc11((XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pStruct);
+ swc11.set_indent(indent);
+ swc11.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ {
+ xgl_image_create_info_struct_wrapper swc12((XGL_IMAGE_CREATE_INFO*)pStruct);
+ swc12.set_indent(indent);
+ swc12.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ {
+ xgl_image_view_attach_info_struct_wrapper swc13((XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct);
+ swc13.set_indent(indent);
+ swc13.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ {
+ xgl_image_view_create_info_struct_wrapper swc14((XGL_IMAGE_VIEW_CREATE_INFO*)pStruct);
+ swc14.set_indent(indent);
+ swc14.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ {
+ xgl_memory_alloc_info_struct_wrapper swc15((XGL_MEMORY_ALLOC_INFO*)pStruct);
+ swc15.set_indent(indent);
+ swc15.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ {
+ xgl_memory_open_info_struct_wrapper swc16((XGL_MEMORY_OPEN_INFO*)pStruct);
+ swc16.set_indent(indent);
+ swc16.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION:
+ {
+ xgl_memory_state_transition_struct_wrapper swc17((XGL_MEMORY_STATE_TRANSITION*)pStruct);
+ swc17.set_indent(indent);
+ swc17.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO:
+ {
+ xgl_memory_view_attach_info_struct_wrapper swc18((XGL_MEMORY_VIEW_ATTACH_INFO*)pStruct);
+ swc18.set_indent(indent);
+ swc18.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO:
+ {
+ xgl_msaa_state_create_info_struct_wrapper swc19((XGL_MSAA_STATE_CREATE_INFO*)pStruct);
+ swc19.set_indent(indent);
+ swc19.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ {
+ xgl_peer_memory_open_info_struct_wrapper swc20((XGL_PEER_MEMORY_OPEN_INFO*)pStruct);
+ swc20.set_indent(indent);
+ swc20.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ {
+ xgl_pipeline_cb_state_create_info_struct_wrapper swc21((XGL_PIPELINE_CB_STATE*)pStruct);
+ swc21.set_indent(indent);
+ swc21.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
+ {
+ xgl_pipeline_db_state_create_info_struct_wrapper swc22((XGL_PIPELINE_DB_STATE_CREATE_INFO*)pStruct);
+ swc22.set_indent(indent);
+ swc22.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ {
+ xgl_pipeline_ia_state_create_info_struct_wrapper swc23((XGL_PIPELINE_IA_STATE_CREATE_INFO*)pStruct);
+ swc23.set_indent(indent);
+ swc23.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ {
+ xgl_pipeline_rs_state_create_info_struct_wrapper swc24((XGL_PIPELINE_RS_STATE_CREATE_INFO*)pStruct);
+ swc24.set_indent(indent);
+ swc24.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ {
+ xgl_pipeline_shader_stage_create_info_struct_wrapper swc25((XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pStruct);
+ swc25.set_indent(indent);
+ swc25.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ {
+ xgl_pipeline_tess_state_create_info_struct_wrapper swc26((XGL_PIPELINE_TESS_STATE_CREATE_INFO*)pStruct);
+ swc26.set_indent(indent);
+ swc26.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ {
+ xgl_query_pool_create_info_struct_wrapper swc27((XGL_QUERY_POOL_CREATE_INFO*)pStruct);
+ swc27.set_indent(indent);
+ swc27.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO:
+ {
+ xgl_raster_state_create_info_struct_wrapper swc28((XGL_RASTER_STATE_CREATE_INFO*)pStruct);
+ swc28.set_indent(indent);
+ swc28.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ {
+ xgl_sampler_create_info_struct_wrapper swc29((XGL_SAMPLER_CREATE_INFO*)pStruct);
+ swc29.set_indent(indent);
+ swc29.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
+ {
+ xgl_queue_semaphore_create_info_struct_wrapper swc30((XGL_QUEUE_SEMAPHORE_CREATE_INFO*)pStruct);
+ swc30.set_indent(indent);
+ swc30.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO:
+ {
+ xgl_queue_semaphore_open_info_struct_wrapper swc31((XGL_QUEUE_SEMAPHORE_OPEN_INFO*)pStruct);
+ swc31.set_indent(indent);
+ swc31.display_full_txt();
+ }
+ break;
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ {
+ xgl_shader_create_info_struct_wrapper swc32((XGL_SHADER_CREATE_INFO*)pStruct);
+ swc32.set_indent(indent);
+ swc32.display_full_txt();
+ }
+ break;
+ }
+}
+
+
+// xgl_raster_state_create_info_struct_wrapper class definition
+xgl_raster_state_create_info_struct_wrapper::xgl_raster_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_raster_state_create_info_struct_wrapper::xgl_raster_state_create_info_struct_wrapper(XGL_RASTER_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_raster_state_create_info_struct_wrapper::xgl_raster_state_create_info_struct_wrapper(const XGL_RASTER_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_raster_state_create_info_struct_wrapper::~xgl_raster_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_raster_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_RASTER_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_raster_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sfillMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FILL_MODE(m_struct.fillMode));
+ printf("%*s %scullMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CULL_MODE(m_struct.cullMode));
+ printf("%*s %sfrontFace = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FACE_ORIENTATION(m_struct.frontFace));
+ printf("%*s %sdepthBias = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBias));
+ printf("%*s %sdepthBiasClamp = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBiasClamp));
+ printf("%*s %sslopeScaledDepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.slopeScaledDepthBias));
+}
+
+// Output all struct elements, each on their own line
+void xgl_raster_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_RASTER_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_raster_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_RASTER_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_gpu_compatibility_info_struct_wrapper class definition
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_gpu_compatibility_info_struct_wrapper::~xgl_gpu_compatibility_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_gpu_compatibility_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_GPU_COMPATIBILITY_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_gpu_compatibility_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %scompatibilityFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.compatibilityFlags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_gpu_compatibility_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_gpu_compatibility_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_image_view_create_info_struct_wrapper class definition
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_view_create_info_struct_wrapper::~xgl_image_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_view_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_view_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_VIEW_TYPE(m_struct.viewType));
+ printf("%*s %sformat = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.format));
+ printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
+ printf("%*s %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
+ printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_view_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_view_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.subresourceRange) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.channels) {
+ xgl_channel_mapping_struct_wrapper class1(&m_struct.channels);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.format) {
+ xgl_format_struct_wrapper class2(&m_struct.format);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_memory_open_info_struct_wrapper class definition
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_memory_heap_properties_struct_wrapper class definition
+xgl_memory_heap_properties_struct_wrapper::xgl_memory_heap_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_heap_properties_struct_wrapper::xgl_memory_heap_properties_struct_wrapper(XGL_MEMORY_HEAP_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_heap_properties_struct_wrapper::xgl_memory_heap_properties_struct_wrapper(const XGL_MEMORY_HEAP_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_heap_properties_struct_wrapper::~xgl_memory_heap_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_heap_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_HEAP_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_heap_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstructSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.structSize));
+ printf("%*s %sheapMemoryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_HEAP_MEMORY_TYPE(m_struct.heapMemoryType));
+ printf("%*s %sheapSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.heapSize));
+ printf("%*s %spageSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.pageSize));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sgpuReadPerfRating = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuReadPerfRating));
+ printf("%*s %sgpuWritePerfRating = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuWritePerfRating));
+ printf("%*s %scpuReadPerfRating = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.cpuReadPerfRating));
+ printf("%*s %scpuWritePerfRating = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.cpuWritePerfRating));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_heap_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_HEAP_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_heap_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_HEAP_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_image_subresource_struct_wrapper class definition
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_subresource_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_subresource_struct_wrapper::display_struct_members()
+{
+ printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_subresource_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_subresource_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_physical_gpu_performance_struct_wrapper class definition
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
+{
+ printf("%*s %smaxGpuClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxGpuClock));
+ printf("%*s %saluPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.aluPerClock));
+ printf("%*s %stexPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.texPerClock));
+ printf("%*s %sprimsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.primsPerClock));
+ printf("%*s %spixelsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pixelsPerClock));
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_performance_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_physical_gpu_memory_properties_struct_wrapper class definition
+xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_memory_properties_struct_wrapper::~xgl_physical_gpu_memory_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstructSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.structSize));
+ printf("%*s %ssupportsMigration = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsMigration) ? "TRUE" : "FALSE");
+ printf("%*s %ssupportsVirtualMemoryRemapping = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsVirtualMemoryRemapping) ? "TRUE" : "FALSE");
+ printf("%*s %ssupportsPinning = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsPinning) ? "TRUE" : "FALSE");
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_memory_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_MEMORY_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_shader_struct_wrapper class definition
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_shader_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_shader_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstage = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PIPELINE_SHADER_STAGE(m_struct.stage));
+ printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.shader));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_DESCRIPTOR_SETS; i++) {
+ printf("%*s %sdescriptorSetMapping[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)&(m_struct.descriptorSetMapping)[i]);
+ }
+ printf("%*s %slinkConstBufferCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linkConstBufferCount));
+ printf("%*s %spLinkConstBufferInfo = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pLinkConstBufferInfo));
+ printf("%*s %sdynamicMemoryViewMapping = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.dynamicMemoryViewMapping));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_shader_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_shader_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.dynamicMemoryViewMapping) {
+ xgl_dynamic_memory_view_slot_info_struct_wrapper class0(&m_struct.dynamicMemoryViewMapping);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pLinkConstBufferInfo) {
+ xgl_link_const_buffer_struct_wrapper class1(m_struct.pLinkConstBufferInfo);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_DESCRIPTOR_SETS; i++) {
+ xgl_descriptor_set_mapping_struct_wrapper class2(&(m_struct.descriptorSetMapping[i]));
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+}
+
+
+// xgl_fence_create_info_struct_wrapper class definition
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_fence_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_fence_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_fence_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_fence_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_cb_attachment_state_struct_wrapper class definition
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sformat = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.format));
+ printf("%*s %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.format) {
+ xgl_format_struct_wrapper class0(&m_struct.format);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+}
+
+
+// xgl_alloc_callbacks_struct_wrapper class definition
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
+{
+ printf("%*s %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
+ printf("%*s %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
+ printf("%*s %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
+}
+
+// Output all struct elements, each on their own line
+void xgl_alloc_callbacks_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_color_attachment_view_create_info_struct_wrapper class definition
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %sformat = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.format));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.format) {
+ xgl_format_struct_wrapper class0(&m_struct.format);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_image_copy_struct_wrapper class definition
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_copy_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_copy_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
+ printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_copy_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_copy_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.destOffset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.destOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.destSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+ if (&m_struct.srcOffset) {
+ xgl_offset3d_struct_wrapper class3(&m_struct.srcOffset);
+ class3.set_indent(m_indent + 4);
+ class3.display_full_txt();
+ }
+ if (&m_struct.srcSubresource) {
+ xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
+ class4.set_indent(m_indent + 4);
+ class4.display_full_txt();
+ }
+}
+
+
+// xgl_msaa_state_create_info_struct_wrapper class definition
+xgl_msaa_state_create_info_struct_wrapper::xgl_msaa_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_msaa_state_create_info_struct_wrapper::xgl_msaa_state_create_info_struct_wrapper(XGL_MSAA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_msaa_state_create_info_struct_wrapper::xgl_msaa_state_create_info_struct_wrapper(const XGL_MSAA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_msaa_state_create_info_struct_wrapper::~xgl_msaa_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_msaa_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MSAA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_msaa_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+ printf("%*s %ssampleMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleMask));
+}
+
+// Output all struct elements, each on their own line
+void xgl_msaa_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MSAA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_msaa_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MSAA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_descriptor_set_create_info_struct_wrapper class definition
+xgl_descriptor_set_create_info_struct_wrapper::xgl_descriptor_set_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_set_create_info_struct_wrapper::xgl_descriptor_set_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_set_create_info_struct_wrapper::xgl_descriptor_set_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_set_create_info_struct_wrapper::~xgl_descriptor_set_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_set_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DESCRIPTOR_SET_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_set_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_set_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SET_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_set_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SET_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_color_attachment_bind_info_struct_wrapper class definition
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %scolorAttachmentState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_STATE(m_struct.colorAttachmentState));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_event_create_info_struct_wrapper class definition
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_event_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_event_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_event_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_event_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_memory_requirements_struct_wrapper class definition
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_requirements_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_requirements_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.size));
+ printf("%*s %salignment = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.alignment));
+ printf("%*s %sheapCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.heapCount));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_MEMORY_HEAPS; i++) {
+ printf("%*s %sheaps[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.heaps)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_requirements_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_requirements_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_queue_semaphore_open_info_struct_wrapper class definition
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
+}
+
+// Output all struct elements, each on their own line
+void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_image_resolve_struct_wrapper class definition
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_resolve_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_resolve_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
+ printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_resolve_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_resolve_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.destOffset) {
+ xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.destSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+ if (&m_struct.srcOffset) {
+ xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
+ class3.set_indent(m_indent + 4);
+ class3.display_full_txt();
+ }
+ if (&m_struct.srcSubresource) {
+ xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
+ class4.set_indent(m_indent + 4);
+ class4.display_full_txt();
+ }
+}
+
+
+// xgl_draw_indexed_indirect_cmd_struct_wrapper class definition
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_draw_indexed_indirect_cmd_struct_wrapper::~xgl_draw_indexed_indirect_cmd_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DRAW_INDEXED_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sindexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.indexCount));
+ printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
+ printf("%*s %sfirstIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstIndex));
+ printf("%*s %svertexOffset = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexOffset));
+ printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
+}
+
+// Output all struct elements, each on their own line
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_compute_pipeline_create_info_struct_wrapper class definition
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.cs) {
+ xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_peer_image_open_info_struct_wrapper class definition
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
+}
+
+// Output all struct elements, each on their own line
+void xgl_peer_image_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_physical_gpu_queue_properties_struct_wrapper class definition
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstructSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.structSize));
+ printf("%*s %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
+ printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+ printf("%*s %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
+ printf("%*s %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_statistics_data_struct_wrapper class definition
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
+ printf("%*s %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
+ printf("%*s %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
+ printf("%*s %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
+ printf("%*s %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
+ printf("%*s %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
+ printf("%*s %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
+ printf("%*s %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
+ printf("%*s %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
+ printf("%*s %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
+ printf("%*s %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_device_queue_create_info_struct_wrapper class definition
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
+ printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+}
+
+// Output all struct elements, each on their own line
+void xgl_device_queue_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_sampler_create_info_struct_wrapper class definition
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_sampler_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_sampler_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %smagFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.magFilter));
+ printf("%*s %sminFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.minFilter));
+ printf("%*s %smipMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_MIPMAP_MODE(m_struct.mipMode));
+ printf("%*s %saddressU = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressU));
+ printf("%*s %saddressV = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressV));
+ printf("%*s %saddressW = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressW));
+ printf("%*s %smipLodBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLodBias));
+ printf("%*s %smaxAnisotropy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAnisotropy));
+ printf("%*s %scompareFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.compareFunc));
+ printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
+ printf("%*s %smaxLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxLod));
+ printf("%*s %sborderColorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BORDER_COLOR_TYPE(m_struct.borderColorType));
+}
+
+// Output all struct elements, each on their own line
+void xgl_sampler_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_sampler_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_queue_semaphore_create_info_struct_wrapper class definition
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_format_struct_wrapper class definition
+xgl_format_struct_wrapper::xgl_format_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_format_struct_wrapper::xgl_format_struct_wrapper(XGL_FORMAT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_format_struct_wrapper::xgl_format_struct_wrapper(const XGL_FORMAT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_format_struct_wrapper::~xgl_format_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_format_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_FORMAT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_format_struct_wrapper::display_struct_members()
+{
+ printf("%*s %schannelFormat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_FORMAT(m_struct.channelFormat));
+ printf("%*s %snumericFormat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_NUM_FORMAT(m_struct.numericFormat));
+}
+
+// Output all struct elements, each on their own line
+void xgl_format_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_FORMAT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_format_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_FORMAT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_memory_state_transition_struct_wrapper class definition
+xgl_memory_state_transition_struct_wrapper::xgl_memory_state_transition_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_state_transition_struct_wrapper::xgl_memory_state_transition_struct_wrapper(XGL_MEMORY_STATE_TRANSITION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_state_transition_struct_wrapper::xgl_memory_state_transition_struct_wrapper(const XGL_MEMORY_STATE_TRANSITION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_state_transition_struct_wrapper::~xgl_memory_state_transition_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_state_transition_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_STATE_TRANSITION = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_state_transition_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
+ printf("%*s %soldState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_STATE(m_struct.oldState));
+ printf("%*s %snewState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_STATE(m_struct.newState));
+ printf("%*s %soffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offset));
+ printf("%*s %sregionSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.regionSize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_state_transition_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_STATE_TRANSITION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_state_transition_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_STATE_TRANSITION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_extent3d_struct_wrapper class definition
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_extent3d_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_extent3d_struct_wrapper::display_struct_members()
+{
+ printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
+}
+
+// Output all struct elements, each on their own line
+void xgl_extent3d_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_extent3d_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_dynamic_memory_view_slot_info_struct_wrapper class definition
+xgl_dynamic_memory_view_slot_info_struct_wrapper::xgl_dynamic_memory_view_slot_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_memory_view_slot_info_struct_wrapper::xgl_dynamic_memory_view_slot_info_struct_wrapper(XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_memory_view_slot_info_struct_wrapper::xgl_dynamic_memory_view_slot_info_struct_wrapper(const XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_memory_view_slot_info_struct_wrapper::~xgl_dynamic_memory_view_slot_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_memory_view_slot_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_memory_view_slot_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sslotObjectType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_SET_SLOT_TYPE(m_struct.slotObjectType));
+ printf("%*s %sshaderEntityIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.shaderEntityIndex));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_memory_view_slot_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_memory_view_slot_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_image_view_attach_info_struct_wrapper class definition
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %sstate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_STATE(m_struct.state));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_view_attach_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_image_subresource_range_struct_wrapper class definition
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_subresource_range_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_subresource_range_struct_wrapper::display_struct_members()
+{
+ printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+ printf("%*s %sbaseMipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseMipLevel));
+ printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_subresource_range_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_subresource_range_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_db_state_create_info_struct_wrapper class definition
+xgl_pipeline_db_state_create_info_struct_wrapper::xgl_pipeline_db_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_db_state_create_info_struct_wrapper::xgl_pipeline_db_state_create_info_struct_wrapper(XGL_PIPELINE_DB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_db_state_create_info_struct_wrapper::xgl_pipeline_db_state_create_info_struct_wrapper(const XGL_PIPELINE_DB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_db_state_create_info_struct_wrapper::~xgl_pipeline_db_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_db_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_DB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_db_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sformat = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.format));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_db_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_DB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_db_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_DB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.format) {
+ xgl_format_struct_wrapper class0(&m_struct.format);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_application_info_struct_wrapper class definition
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_application_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_application_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
+ printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
+ printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
+ printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
+ printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+}
+
+// Output all struct elements, each on their own line
+void xgl_application_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_application_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_offset2d_struct_wrapper class definition
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_offset2d_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_offset2d_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+}
+
+// Output all struct elements, each on their own line
+void xgl_offset2d_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_offset2d_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_viewport_state_create_info_struct_wrapper class definition
+xgl_viewport_state_create_info_struct_wrapper::xgl_viewport_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_viewport_state_create_info_struct_wrapper::xgl_viewport_state_create_info_struct_wrapper(XGL_VIEWPORT_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_viewport_state_create_info_struct_wrapper::xgl_viewport_state_create_info_struct_wrapper(const XGL_VIEWPORT_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_viewport_state_create_info_struct_wrapper::~xgl_viewport_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_viewport_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_VIEWPORT_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_viewport_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sviewportCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportCount));
+ printf("%*s %sscissorEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.scissorEnable) ? "TRUE" : "FALSE");
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_VIEWPORTS; i++) {
+ printf("%*s %sviewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)&(m_struct.viewports)[i]);
+ }
+ for (i = 0; i<XGL_MAX_VIEWPORTS; i++) {
+ printf("%*s %sscissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)&(m_struct.scissors)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_viewport_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_VIEWPORT_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_viewport_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_VIEWPORT_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_VIEWPORTS; i++) {
+ xgl_rect_struct_wrapper class0(&(m_struct.scissors[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ for (i = 0; i<XGL_MAX_VIEWPORTS; i++) {
+ xgl_viewport_struct_wrapper class1(&(m_struct.viewports[i]));
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+}
+
+
+// xgl_image_state_transition_struct_wrapper class definition
+xgl_image_state_transition_struct_wrapper::xgl_image_state_transition_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_state_transition_struct_wrapper::xgl_image_state_transition_struct_wrapper(XGL_IMAGE_STATE_TRANSITION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_state_transition_struct_wrapper::xgl_image_state_transition_struct_wrapper(const XGL_IMAGE_STATE_TRANSITION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_state_transition_struct_wrapper::~xgl_image_state_transition_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_state_transition_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_STATE_TRANSITION = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_state_transition_struct_wrapper::display_struct_members()
+{
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %soldState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_STATE(m_struct.oldState));
+ printf("%*s %snewState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_STATE(m_struct.newState));
+ printf("%*s %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_state_transition_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_STATE_TRANSITION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_state_transition_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_STATE_TRANSITION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.subresourceRange) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+}
+
+
+// xgl_device_create_info_struct_wrapper class definition
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_device_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_device_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeueRecordCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueRecordCount));
+ printf("%*s %spRequestedQueues = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pRequestedQueues));
+ printf("%*s %sextensionCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.extensionCount));
+ printf("%*s %sppEnabledExtensionNames = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.ppEnabledExtensionNames));
+ printf("%*s %smaxValidationLevel = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VALIDATION_LEVEL(m_struct.maxValidationLevel));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_device_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_device_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pRequestedQueues) {
+ xgl_device_queue_create_info_struct_wrapper class0(m_struct.pRequestedQueues);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_image_create_info_struct_wrapper class definition
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
+ printf("%*s %sformat = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.format));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+ printf("%*s %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.format) {
+ xgl_format_struct_wrapper class1(&m_struct.format);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_rect_struct_wrapper class definition
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_rect_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_rect_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_rect_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_rect_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.offset) {
+ xgl_offset2d_struct_wrapper class1(&m_struct.offset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+}
+
+
+// xgl_memory_copy_struct_wrapper class definition
+xgl_memory_copy_struct_wrapper::xgl_memory_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_copy_struct_wrapper::xgl_memory_copy_struct_wrapper(XGL_MEMORY_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_copy_struct_wrapper::xgl_memory_copy_struct_wrapper(const XGL_MEMORY_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_copy_struct_wrapper::~xgl_memory_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_copy_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_copy_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssrcOffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.srcOffset));
+ printf("%*s %sdestOffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.destOffset));
+ printf("%*s %scopySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.copySize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_copy_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_copy_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_descriptor_slot_info_struct_wrapper class definition
+xgl_descriptor_slot_info_struct_wrapper::xgl_descriptor_slot_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_slot_info_struct_wrapper::xgl_descriptor_slot_info_struct_wrapper(XGL_DESCRIPTOR_SLOT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_slot_info_struct_wrapper::xgl_descriptor_slot_info_struct_wrapper(const XGL_DESCRIPTOR_SLOT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_slot_info_struct_wrapper::~xgl_descriptor_slot_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_slot_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DESCRIPTOR_SLOT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_slot_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sslotObjectType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_SET_SLOT_TYPE(m_struct.slotObjectType));
+ printf("%*s %sshaderEntityIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.shaderEntityIndex));
+ printf("%*s %spNextLevelSet = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNextLevelSet));
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_slot_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SLOT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_slot_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SLOT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_link_const_buffer_struct_wrapper class definition
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_link_const_buffer_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_link_const_buffer_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
+ printf("%*s %sbufferSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferSize));
+ printf("%*s %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
+}
+
+// Output all struct elements, each on their own line
+void xgl_link_const_buffer_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_link_const_buffer_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_memory_image_copy_struct_wrapper class definition
+xgl_memory_image_copy_struct_wrapper::xgl_memory_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_image_copy_struct_wrapper::xgl_memory_image_copy_struct_wrapper(XGL_MEMORY_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_image_copy_struct_wrapper::xgl_memory_image_copy_struct_wrapper(const XGL_MEMORY_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_image_copy_struct_wrapper::~xgl_memory_image_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_image_copy_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_image_copy_struct_wrapper::display_struct_members()
+{
+ printf("%*s %smemOffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memOffset));
+ printf("%*s %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
+ printf("%*s %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
+ printf("%*s %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_image_copy_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_image_copy_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.imageExtent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.imageOffset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.imageSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+}
+
+
+// xgl_depth_stencil_state_create_info_struct_wrapper class definition
+xgl_depth_stencil_state_create_info_struct_wrapper::xgl_depth_stencil_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_state_create_info_struct_wrapper::xgl_depth_stencil_state_create_info_struct_wrapper(XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_state_create_info_struct_wrapper::xgl_depth_stencil_state_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_state_create_info_struct_wrapper::~xgl_depth_stencil_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEPTH_STENCIL_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
+ printf("%*s %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+ printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+ printf("%*s %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sstencilReadMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilReadMask));
+ printf("%*s %sstencilWriteMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilWriteMask));
+ printf("%*s %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
+ printf("%*s %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.back) {
+ xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.front) {
+ xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_viewport_struct_wrapper class definition
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_viewport_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_VIEWPORT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_viewport_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soriginX = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originX));
+ printf("%*s %soriginY = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originY));
+ printf("%*s %swidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+ printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+}
+
+// Output all struct elements, each on their own line
+void xgl_viewport_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_viewport_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_descriptor_set_mapping_struct_wrapper class definition
+xgl_descriptor_set_mapping_struct_wrapper::xgl_descriptor_set_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_set_mapping_struct_wrapper::xgl_descriptor_set_mapping_struct_wrapper(XGL_DESCRIPTOR_SET_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_set_mapping_struct_wrapper::xgl_descriptor_set_mapping_struct_wrapper(const XGL_DESCRIPTOR_SET_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_set_mapping_struct_wrapper::~xgl_descriptor_set_mapping_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_set_mapping_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DESCRIPTOR_SET_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_set_mapping_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sdescriptorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorCount));
+ printf("%*s %spDescriptorInfo = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pDescriptorInfo));
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_set_mapping_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SET_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_set_mapping_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SET_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pDescriptorInfo) {
+ xgl_descriptor_slot_info_struct_wrapper class0(m_struct.pDescriptorInfo);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+}
+
+
+// xgl_peer_memory_open_info_struct_wrapper class definition
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_peer_memory_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_subresource_layout_struct_wrapper class definition
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_subresource_layout_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_SUBRESOURCE_LAYOUT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_subresource_layout_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offset));
+ printf("%*s %ssize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.size));
+ printf("%*s %srowPitch = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.rowPitch));
+ printf("%*s %sdepthPitch = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.depthPitch));
+}
+
+// Output all struct elements, each on their own line
+void xgl_subresource_layout_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_subresource_layout_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_descriptor_set_attach_info_struct_wrapper class definition
+xgl_descriptor_set_attach_info_struct_wrapper::xgl_descriptor_set_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_set_attach_info_struct_wrapper::xgl_descriptor_set_attach_info_struct_wrapper(XGL_DESCRIPTOR_SET_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_set_attach_info_struct_wrapper::xgl_descriptor_set_attach_info_struct_wrapper(const XGL_DESCRIPTOR_SET_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_set_attach_info_struct_wrapper::~xgl_descriptor_set_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_set_attach_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DESCRIPTOR_SET_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_set_attach_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
+ printf("%*s %sslotOffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slotOffset));
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_set_attach_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SET_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_set_attach_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_SET_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_tess_state_create_info_struct_wrapper class definition
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %spatchControlPoints = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.patchControlPoints));
+ printf("%*s %soptimalTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTessFactor));
+ printf("%*s %sfixedTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.fixedTessFactor));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_rs_state_create_info_struct_wrapper class definition
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_rs_state_create_info_struct_wrapper::~xgl_pipeline_rs_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdepthClipEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthClipEnable) ? "TRUE" : "FALSE");
+ printf("%*s %srasterizerDiscardEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.rasterizerDiscardEnable) ? "TRUE" : "FALSE");
+ printf("%*s %spointSize = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointSize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_stencil_op_state_struct_wrapper class definition
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_stencil_op_state_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_stencil_op_state_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
+ printf("%*s %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
+ printf("%*s %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
+ printf("%*s %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
+ printf("%*s %sstencilRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilRef));
+}
+
+// Output all struct elements, each on their own line
+void xgl_stencil_op_state_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_stencil_op_state_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_shader_create_info_struct_wrapper class definition
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_shader_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_shader_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %scodeSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.codeSize));
+ printf("%*s %spCode = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pCode));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_shader_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_shader_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_color_blend_state_create_info_struct_wrapper class definition
+xgl_color_blend_state_create_info_struct_wrapper::xgl_color_blend_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_blend_state_create_info_struct_wrapper::xgl_color_blend_state_create_info_struct_wrapper(XGL_COLOR_BLEND_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_blend_state_create_info_struct_wrapper::xgl_color_blend_state_create_info_struct_wrapper(const XGL_COLOR_BLEND_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_blend_state_create_info_struct_wrapper::~xgl_color_blend_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_blend_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COLOR_BLEND_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_blend_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_COLOR_ATTACHMENTS; i++) {
+ printf("%*s %sattachment[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)&(m_struct.attachment)[i]);
+ }
+ for (i = 0; i<4; i++) {
+ printf("%*s %sblendConst[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.blendConst)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_blend_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_BLEND_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_blend_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_BLEND_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_COLOR_ATTACHMENTS; i++) {
+ xgl_color_attachment_blend_state_struct_wrapper class0(&(m_struct.attachment[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_CB_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdualSourceBlendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.dualSourceBlendEnable) ? "TRUE" : "FALSE");
+ printf("%*s %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_COLOR_ATTACHMENTS; i++) {
+ printf("%*s %sattachment[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)&(m_struct.attachment)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_COLOR_ATTACHMENTS; i++) {
+ xgl_pipeline_cb_attachment_state_struct_wrapper class0(&(m_struct.attachment[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_channel_mapping_struct_wrapper class definition
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_channel_mapping_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_channel_mapping_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sr = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.r));
+ printf("%*s %sg = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.g));
+ printf("%*s %sb = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.b));
+ printf("%*s %sa = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.a));
+}
+
+// Output all struct elements, each on their own line
+void xgl_channel_mapping_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_channel_mapping_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_depth_stencil_view_create_info_struct_wrapper class definition
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_virtual_memory_remap_range_struct_wrapper class definition
+xgl_virtual_memory_remap_range_struct_wrapper::xgl_virtual_memory_remap_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_virtual_memory_remap_range_struct_wrapper::xgl_virtual_memory_remap_range_struct_wrapper(XGL_VIRTUAL_MEMORY_REMAP_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_virtual_memory_remap_range_struct_wrapper::xgl_virtual_memory_remap_range_struct_wrapper(const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_virtual_memory_remap_range_struct_wrapper::~xgl_virtual_memory_remap_range_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_virtual_memory_remap_range_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_VIRTUAL_MEMORY_REMAP_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_virtual_memory_remap_range_struct_wrapper::display_struct_members()
+{
+ printf("%*s %svirtualMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.virtualMem));
+ printf("%*s %svirtualStartPage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.virtualStartPage));
+ printf("%*s %srealMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.realMem));
+ printf("%*s %srealStartPage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.realStartPage));
+ printf("%*s %spageCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.pageCount));
+}
+
+// Output all struct elements, each on their own line
+void xgl_virtual_memory_remap_range_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_VIRTUAL_MEMORY_REMAP_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_virtual_memory_remap_range_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_VIRTUAL_MEMORY_REMAP_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_cmd_buffer_create_info_struct_wrapper class definition
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_format_properties_struct_wrapper class definition
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_format_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_format_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
+ printf("%*s %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
+}
+
+// Output all struct elements, each on their own line
+void xgl_format_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_format_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_physical_gpu_properties_struct_wrapper class definition
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstructSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.structSize));
+ printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+ printf("%*s %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
+ printf("%*s %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
+ printf("%*s %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
+ printf("%*s %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
+ printf("%*s %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
+ }
+ printf("%*s %smaxMemRefsPerSubmission = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxMemRefsPerSubmission));
+ printf("%*s %svirtualMemPageSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.virtualMemPageSize));
+ printf("%*s %smaxInlineMemoryUpdateSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxInlineMemoryUpdateSize));
+ printf("%*s %smaxBoundDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxBoundDescriptorSets));
+ printf("%*s %smaxThreadGroupSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxThreadGroupSize));
+ printf("%*s %stimestampFrequency = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.timestampFrequency));
+ printf("%*s %smultiColorAttachmentClears = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multiColorAttachmentClears) ? "TRUE" : "FALSE");
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_depth_stencil_bind_info_struct_wrapper class definition
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %sdepthState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_STATE(m_struct.depthState));
+ printf("%*s %sstencilState = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_STATE(m_struct.stencilState));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_draw_indirect_cmd_struct_wrapper class definition
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
+{
+ printf("%*s %svertexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexCount));
+ printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
+ printf("%*s %sfirstVertex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstVertex));
+ printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
+}
+
+// Output all struct elements, each on their own line
+void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_graphics_pipeline_create_info_struct_wrapper class definition
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
+ printf("%*s %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
+ printf("%*s %sprovokingVertex = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(m_struct.provokingVertex));
+ printf("%*s %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_color_attachment_blend_state_struct_wrapper class definition
+xgl_color_attachment_blend_state_struct_wrapper::xgl_color_attachment_blend_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_blend_state_struct_wrapper::xgl_color_attachment_blend_state_struct_wrapper(XGL_COLOR_ATTACHMENT_BLEND_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_blend_state_struct_wrapper::xgl_color_attachment_blend_state_struct_wrapper(const XGL_COLOR_ATTACHMENT_BLEND_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_blend_state_struct_wrapper::~xgl_color_attachment_blend_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_blend_state_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COLOR_ATTACHMENT_BLEND_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_blend_state_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
+ printf("%*s %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
+ printf("%*s %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
+ printf("%*s %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
+ printf("%*s %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
+ printf("%*s %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
+ printf("%*s %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_blend_state_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BLEND_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_blend_state_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BLEND_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_extent2d_struct_wrapper class definition
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_extent2d_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_EXTENT2D = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_extent2d_struct_wrapper::display_struct_members()
+{
+ printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+}
+
+// Output all struct elements, each on their own line
+void xgl_extent2d_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_extent2d_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_memory_alloc_info_struct_wrapper class definition
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sallocationSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.allocationSize));
+ printf("%*s %salignment = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.alignment));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sheapCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.heapCount));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_MEMORY_HEAPS; i++) {
+ printf("%*s %sheaps[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.heaps)[i]);
+ }
+ printf("%*s %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_alloc_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_memory_ref_struct_wrapper class definition
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_ref_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_ref_struct_wrapper::display_struct_members()
+{
+ printf("%*s %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_ref_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_ref_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_query_pool_create_info_struct_wrapper class definition
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
+ printf("%*s %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
+}
+
+// Output all struct elements, each on their own line
+void xgl_query_pool_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_offset3d_struct_wrapper class definition
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_offset3d_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_offset3d_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+ printf("%*s %sz = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+}
+
+// Output all struct elements, each on their own line
+void xgl_offset3d_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_offset3d_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_shader_stage_create_info_struct_wrapper class definition
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.shader) {
+ xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_memory_view_attach_info_struct_wrapper class definition
+xgl_memory_view_attach_info_struct_wrapper::xgl_memory_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_view_attach_info_struct_wrapper::xgl_memory_view_attach_info_struct_wrapper(XGL_MEMORY_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_view_attach_info_struct_wrapper::xgl_memory_view_attach_info_struct_wrapper(const XGL_MEMORY_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_view_attach_info_struct_wrapper::~xgl_memory_view_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_view_attach_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_view_attach_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
+ printf("%*s %soffset = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offset));
+ printf("%*s %srange = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.range));
+ printf("%*s %sstride = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stride));
+ printf("%*s %sformat = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.format));
+ printf("%*s %sstate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_STATE(m_struct.state));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_view_attach_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_view_attach_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.format) {
+ xgl_format_struct_wrapper class0(&m_struct.format);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_dispatch_indirect_cmd_struct_wrapper class definition
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sx = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+ printf("%*s %sz = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+//any footer info for class
diff --git a/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_wrappers.h b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_wrappers.h
new file mode 100644
index 0000000..360c0f9
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glave_xgl_gen/xgl_struct_wrappers.h
@@ -0,0 +1,2799 @@
+//This is the copyright
+//#includes, #defines, globals and such...
+#include <xgl.h>
+#include <xgl_string_helper.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+//class declaration
+class xgl_raster_state_create_info_struct_wrapper
+{
+public:
+ xgl_raster_state_create_info_struct_wrapper();
+ xgl_raster_state_create_info_struct_wrapper(XGL_RASTER_STATE_CREATE_INFO* pInStruct);
+ xgl_raster_state_create_info_struct_wrapper(const XGL_RASTER_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_raster_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
+ void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
+ XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
+ void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
+ XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
+ void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
+ XGL_INT get_depthBias() { return m_struct.depthBias; }
+ void set_depthBias(XGL_INT inValue) { m_struct.depthBias = inValue; }
+ XGL_FLOAT get_depthBiasClamp() { return m_struct.depthBiasClamp; }
+ void set_depthBiasClamp(XGL_FLOAT inValue) { m_struct.depthBiasClamp = inValue; }
+ XGL_FLOAT get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
+ void set_slopeScaledDepthBias(XGL_FLOAT inValue) { m_struct.slopeScaledDepthBias = inValue; }
+
+
+private:
+ XGL_RASTER_STATE_CREATE_INFO m_struct;
+ const XGL_RASTER_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_gpu_compatibility_info_struct_wrapper
+{
+public:
+ xgl_gpu_compatibility_info_struct_wrapper();
+ xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct);
+ xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct);
+
+ virtual ~xgl_gpu_compatibility_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_FLAGS get_compatibilityFlags() { return m_struct.compatibilityFlags; }
+ void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = inValue; }
+
+
+private:
+ XGL_GPU_COMPATIBILITY_INFO m_struct;
+ const XGL_GPU_COMPATIBILITY_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_view_create_info_struct_wrapper
+{
+public:
+ xgl_image_view_create_info_struct_wrapper();
+ xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+ xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_image_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+ void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+ void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+ void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+ XGL_FLOAT get_minLod() { return m_struct.minLod; }
+ void set_minLod(XGL_FLOAT inValue) { m_struct.minLod = inValue; }
+
+
+private:
+ XGL_IMAGE_VIEW_CREATE_INFO m_struct;
+ const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_open_info_struct_wrapper
+{
+public:
+ xgl_memory_open_info_struct_wrapper();
+ xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
+ xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_memory_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
+ void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
+
+
+private:
+ XGL_MEMORY_OPEN_INFO m_struct;
+ const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_heap_properties_struct_wrapper
+{
+public:
+ xgl_memory_heap_properties_struct_wrapper();
+ xgl_memory_heap_properties_struct_wrapper(XGL_MEMORY_HEAP_PROPERTIES* pInStruct);
+ xgl_memory_heap_properties_struct_wrapper(const XGL_MEMORY_HEAP_PROPERTIES* pInStruct);
+
+ virtual ~xgl_memory_heap_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_SIZE get_structSize() { return m_struct.structSize; }
+ void set_structSize(XGL_SIZE inValue) { m_struct.structSize = inValue; }
+ XGL_HEAP_MEMORY_TYPE get_heapMemoryType() { return m_struct.heapMemoryType; }
+ void set_heapMemoryType(XGL_HEAP_MEMORY_TYPE inValue) { m_struct.heapMemoryType = inValue; }
+ XGL_GPU_SIZE get_heapSize() { return m_struct.heapSize; }
+ void set_heapSize(XGL_GPU_SIZE inValue) { m_struct.heapSize = inValue; }
+ XGL_GPU_SIZE get_pageSize() { return m_struct.pageSize; }
+ void set_pageSize(XGL_GPU_SIZE inValue) { m_struct.pageSize = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_FLOAT get_gpuReadPerfRating() { return m_struct.gpuReadPerfRating; }
+ void set_gpuReadPerfRating(XGL_FLOAT inValue) { m_struct.gpuReadPerfRating = inValue; }
+ XGL_FLOAT get_gpuWritePerfRating() { return m_struct.gpuWritePerfRating; }
+ void set_gpuWritePerfRating(XGL_FLOAT inValue) { m_struct.gpuWritePerfRating = inValue; }
+ XGL_FLOAT get_cpuReadPerfRating() { return m_struct.cpuReadPerfRating; }
+ void set_cpuReadPerfRating(XGL_FLOAT inValue) { m_struct.cpuReadPerfRating = inValue; }
+ XGL_FLOAT get_cpuWritePerfRating() { return m_struct.cpuWritePerfRating; }
+ void set_cpuWritePerfRating(XGL_FLOAT inValue) { m_struct.cpuWritePerfRating = inValue; }
+
+
+private:
+ XGL_MEMORY_HEAP_PROPERTIES m_struct;
+ const XGL_MEMORY_HEAP_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_subresource_struct_wrapper
+{
+public:
+ xgl_image_subresource_struct_wrapper();
+ xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct);
+ xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct);
+
+ virtual ~xgl_image_subresource_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
+ void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+ XGL_UINT get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(XGL_UINT inValue) { m_struct.mipLevel = inValue; }
+ XGL_UINT get_arraySlice() { return m_struct.arraySlice; }
+ void set_arraySlice(XGL_UINT inValue) { m_struct.arraySlice = inValue; }
+
+
+private:
+ XGL_IMAGE_SUBRESOURCE m_struct;
+ const XGL_IMAGE_SUBRESOURCE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_performance_struct_wrapper
+{
+public:
+ xgl_physical_gpu_performance_struct_wrapper();
+ xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+ xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+
+ virtual ~xgl_physical_gpu_performance_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_FLOAT get_maxGpuClock() { return m_struct.maxGpuClock; }
+ void set_maxGpuClock(XGL_FLOAT inValue) { m_struct.maxGpuClock = inValue; }
+ XGL_FLOAT get_aluPerClock() { return m_struct.aluPerClock; }
+ void set_aluPerClock(XGL_FLOAT inValue) { m_struct.aluPerClock = inValue; }
+ XGL_FLOAT get_texPerClock() { return m_struct.texPerClock; }
+ void set_texPerClock(XGL_FLOAT inValue) { m_struct.texPerClock = inValue; }
+ XGL_FLOAT get_primsPerClock() { return m_struct.primsPerClock; }
+ void set_primsPerClock(XGL_FLOAT inValue) { m_struct.primsPerClock = inValue; }
+ XGL_FLOAT get_pixelsPerClock() { return m_struct.pixelsPerClock; }
+ void set_pixelsPerClock(XGL_FLOAT inValue) { m_struct.pixelsPerClock = inValue; }
+
+
+private:
+ XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
+ const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_memory_properties_struct_wrapper
+{
+public:
+ xgl_physical_gpu_memory_properties_struct_wrapper();
+ xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+ xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+
+ virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_SIZE get_structSize() { return m_struct.structSize; }
+ void set_structSize(XGL_SIZE inValue) { m_struct.structSize = inValue; }
+ XGL_BOOL get_supportsMigration() { return m_struct.supportsMigration; }
+ void set_supportsMigration(XGL_BOOL inValue) { m_struct.supportsMigration = inValue; }
+ XGL_BOOL get_supportsVirtualMemoryRemapping() { return m_struct.supportsVirtualMemoryRemapping; }
+ void set_supportsVirtualMemoryRemapping(XGL_BOOL inValue) { m_struct.supportsVirtualMemoryRemapping = inValue; }
+ XGL_BOOL get_supportsPinning() { return m_struct.supportsPinning; }
+ void set_supportsPinning(XGL_BOOL inValue) { m_struct.supportsPinning = inValue; }
+
+
+private:
+ XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_shader_struct_wrapper
+{
+public:
+ xgl_pipeline_shader_struct_wrapper();
+ xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
+ xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
+
+ virtual ~xgl_pipeline_shader_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
+ void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
+ XGL_SHADER get_shader() { return m_struct.shader; }
+ void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
+ XGL_UINT get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
+ void set_linkConstBufferCount(XGL_UINT inValue) { m_struct.linkConstBufferCount = inValue; }
+ const XGL_LINK_CONST_BUFFER* get_pLinkConstBufferInfo() { return m_struct.pLinkConstBufferInfo; }
+ XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO get_dynamicMemoryViewMapping() { return m_struct.dynamicMemoryViewMapping; }
+ void set_dynamicMemoryViewMapping(XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO inValue) { m_struct.dynamicMemoryViewMapping = inValue; }
+
+
+private:
+ XGL_PIPELINE_SHADER m_struct;
+ const XGL_PIPELINE_SHADER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_fence_create_info_struct_wrapper
+{
+public:
+ xgl_fence_create_info_struct_wrapper();
+ xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
+ xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_fence_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_FENCE_CREATE_INFO m_struct;
+ const XGL_FENCE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_cb_attachment_state_struct_wrapper
+{
+public:
+ xgl_pipeline_cb_attachment_state_struct_wrapper();
+ xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+ xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+
+ virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_BOOL get_blendEnable() { return m_struct.blendEnable; }
+ void set_blendEnable(XGL_BOOL inValue) { m_struct.blendEnable = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_UINT8 get_channelWriteMask() { return m_struct.channelWriteMask; }
+ void set_channelWriteMask(XGL_UINT8 inValue) { m_struct.channelWriteMask = inValue; }
+
+
+private:
+ XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
+ const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_alloc_callbacks_struct_wrapper
+{
+public:
+ xgl_alloc_callbacks_struct_wrapper();
+ xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
+ xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
+
+ virtual ~xgl_alloc_callbacks_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_VOID* get_pUserData() { return m_struct.pUserData; }
+ void set_pUserData(XGL_VOID* inValue) { m_struct.pUserData = inValue; }
+ XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
+ void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
+ XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
+ void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
+
+
+private:
+ XGL_ALLOC_CALLBACKS m_struct;
+ const XGL_ALLOC_CALLBACKS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_view_create_info_struct_wrapper
+{
+public:
+ xgl_color_attachment_view_create_info_struct_wrapper();
+ xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+ xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_UINT get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(XGL_UINT inValue) { m_struct.mipLevel = inValue; }
+ XGL_UINT get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(XGL_UINT inValue) { m_struct.baseArraySlice = inValue; }
+ XGL_UINT get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(XGL_UINT inValue) { m_struct.arraySize = inValue; }
+
+
+private:
+ XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_copy_struct_wrapper
+{
+public:
+ xgl_image_copy_struct_wrapper();
+ xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
+ xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
+
+ virtual ~xgl_image_copy_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+ void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+ XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+ void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+ XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_IMAGE_COPY m_struct;
+ const XGL_IMAGE_COPY* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_msaa_state_create_info_struct_wrapper
+{
+public:
+ xgl_msaa_state_create_info_struct_wrapper();
+ xgl_msaa_state_create_info_struct_wrapper(XGL_MSAA_STATE_CREATE_INFO* pInStruct);
+ xgl_msaa_state_create_info_struct_wrapper(const XGL_MSAA_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_msaa_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_UINT get_samples() { return m_struct.samples; }
+ void set_samples(XGL_UINT inValue) { m_struct.samples = inValue; }
+ XGL_SAMPLE_MASK get_sampleMask() { return m_struct.sampleMask; }
+ void set_sampleMask(XGL_SAMPLE_MASK inValue) { m_struct.sampleMask = inValue; }
+
+
+private:
+ XGL_MSAA_STATE_CREATE_INFO m_struct;
+ const XGL_MSAA_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_set_create_info_struct_wrapper
+{
+public:
+ xgl_descriptor_set_create_info_struct_wrapper();
+ xgl_descriptor_set_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_CREATE_INFO* pInStruct);
+ xgl_descriptor_set_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_descriptor_set_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_UINT get_slots() { return m_struct.slots; }
+ void set_slots(XGL_UINT inValue) { m_struct.slots = inValue; }
+
+
+private:
+ XGL_DESCRIPTOR_SET_CREATE_INFO m_struct;
+ const XGL_DESCRIPTOR_SET_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_bind_info_struct_wrapper
+{
+public:
+ xgl_color_attachment_bind_info_struct_wrapper();
+ xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+ xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+
+ virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_STATE get_colorAttachmentState() { return m_struct.colorAttachmentState; }
+ void set_colorAttachmentState(XGL_IMAGE_STATE inValue) { m_struct.colorAttachmentState = inValue; }
+
+
+private:
+ XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_event_create_info_struct_wrapper
+{
+public:
+ xgl_event_create_info_struct_wrapper();
+ xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
+ xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_event_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_EVENT_CREATE_INFO m_struct;
+ const XGL_EVENT_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_requirements_struct_wrapper
+{
+public:
+ xgl_memory_requirements_struct_wrapper();
+ xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
+
+ virtual ~xgl_memory_requirements_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+ XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
+ void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
+ XGL_UINT get_heapCount() { return m_struct.heapCount; }
+ void set_heapCount(XGL_UINT inValue) { m_struct.heapCount = inValue; }
+
+
+private:
+ XGL_MEMORY_REQUIREMENTS m_struct;
+ const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_queue_semaphore_open_info_struct_wrapper
+{
+public:
+ xgl_queue_semaphore_open_info_struct_wrapper();
+ xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+ xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
+ void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
+
+
+private:
+ XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_resolve_struct_wrapper
+{
+public:
+ xgl_image_resolve_struct_wrapper();
+ xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
+ xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
+
+ virtual ~xgl_image_resolve_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+ void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+ XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+ void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+ XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
+ XGL_EXTENT2D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_IMAGE_RESOLVE m_struct;
+ const XGL_IMAGE_RESOLVE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_draw_indexed_indirect_cmd_struct_wrapper
+{
+public:
+ xgl_draw_indexed_indirect_cmd_struct_wrapper();
+ xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+ xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+
+ virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT32 get_indexCount() { return m_struct.indexCount; }
+ void set_indexCount(XGL_UINT32 inValue) { m_struct.indexCount = inValue; }
+ XGL_UINT32 get_instanceCount() { return m_struct.instanceCount; }
+ void set_instanceCount(XGL_UINT32 inValue) { m_struct.instanceCount = inValue; }
+ XGL_UINT32 get_firstIndex() { return m_struct.firstIndex; }
+ void set_firstIndex(XGL_UINT32 inValue) { m_struct.firstIndex = inValue; }
+ XGL_INT32 get_vertexOffset() { return m_struct.vertexOffset; }
+ void set_vertexOffset(XGL_INT32 inValue) { m_struct.vertexOffset = inValue; }
+ XGL_UINT32 get_firstInstance() { return m_struct.firstInstance; }
+ void set_firstInstance(XGL_UINT32 inValue) { m_struct.firstInstance = inValue; }
+
+
+private:
+ XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
+ const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_compute_pipeline_create_info_struct_wrapper
+{
+public:
+ xgl_compute_pipeline_create_info_struct_wrapper();
+ xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
+ void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_peer_image_open_info_struct_wrapper
+{
+public:
+ xgl_peer_image_open_info_struct_wrapper();
+ xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+ xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_peer_image_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
+ void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
+
+
+private:
+ XGL_PEER_IMAGE_OPEN_INFO m_struct;
+ const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_queue_properties_struct_wrapper
+{
+public:
+ xgl_physical_gpu_queue_properties_struct_wrapper();
+ xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+ xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+
+ virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_SIZE get_structSize() { return m_struct.structSize; }
+ void set_structSize(XGL_SIZE inValue) { m_struct.structSize = inValue; }
+ XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
+ void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
+ XGL_UINT get_queueCount() { return m_struct.queueCount; }
+ void set_queueCount(XGL_UINT inValue) { m_struct.queueCount = inValue; }
+ XGL_UINT get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
+ void set_maxAtomicCounters(XGL_UINT inValue) { m_struct.maxAtomicCounters = inValue; }
+ XGL_BOOL get_supportsTimestamps() { return m_struct.supportsTimestamps; }
+ void set_supportsTimestamps(XGL_BOOL inValue) { m_struct.supportsTimestamps = inValue; }
+
+
+private:
+ XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_statistics_data_struct_wrapper
+{
+public:
+ xgl_pipeline_statistics_data_struct_wrapper();
+ xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+ xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+
+ virtual ~xgl_pipeline_statistics_data_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT64 get_fsInvocations() { return m_struct.fsInvocations; }
+ void set_fsInvocations(XGL_UINT64 inValue) { m_struct.fsInvocations = inValue; }
+ XGL_UINT64 get_cPrimitives() { return m_struct.cPrimitives; }
+ void set_cPrimitives(XGL_UINT64 inValue) { m_struct.cPrimitives = inValue; }
+ XGL_UINT64 get_cInvocations() { return m_struct.cInvocations; }
+ void set_cInvocations(XGL_UINT64 inValue) { m_struct.cInvocations = inValue; }
+ XGL_UINT64 get_vsInvocations() { return m_struct.vsInvocations; }
+ void set_vsInvocations(XGL_UINT64 inValue) { m_struct.vsInvocations = inValue; }
+ XGL_UINT64 get_gsInvocations() { return m_struct.gsInvocations; }
+ void set_gsInvocations(XGL_UINT64 inValue) { m_struct.gsInvocations = inValue; }
+ XGL_UINT64 get_gsPrimitives() { return m_struct.gsPrimitives; }
+ void set_gsPrimitives(XGL_UINT64 inValue) { m_struct.gsPrimitives = inValue; }
+ XGL_UINT64 get_iaPrimitives() { return m_struct.iaPrimitives; }
+ void set_iaPrimitives(XGL_UINT64 inValue) { m_struct.iaPrimitives = inValue; }
+ XGL_UINT64 get_iaVertices() { return m_struct.iaVertices; }
+ void set_iaVertices(XGL_UINT64 inValue) { m_struct.iaVertices = inValue; }
+ XGL_UINT64 get_tcsInvocations() { return m_struct.tcsInvocations; }
+ void set_tcsInvocations(XGL_UINT64 inValue) { m_struct.tcsInvocations = inValue; }
+ XGL_UINT64 get_tesInvocations() { return m_struct.tesInvocations; }
+ void set_tesInvocations(XGL_UINT64 inValue) { m_struct.tesInvocations = inValue; }
+ XGL_UINT64 get_csInvocations() { return m_struct.csInvocations; }
+ void set_csInvocations(XGL_UINT64 inValue) { m_struct.csInvocations = inValue; }
+
+
+private:
+ XGL_PIPELINE_STATISTICS_DATA m_struct;
+ const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_device_queue_create_info_struct_wrapper
+{
+public:
+ xgl_device_queue_create_info_struct_wrapper();
+ xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+ xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_device_queue_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT get_queueNodeIndex() { return m_struct.queueNodeIndex; }
+ void set_queueNodeIndex(XGL_UINT inValue) { m_struct.queueNodeIndex = inValue; }
+ XGL_UINT get_queueCount() { return m_struct.queueCount; }
+ void set_queueCount(XGL_UINT inValue) { m_struct.queueCount = inValue; }
+
+
+private:
+ XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
+ const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_sampler_create_info_struct_wrapper
+{
+public:
+ xgl_sampler_create_info_struct_wrapper();
+ xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct);
+ xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_sampler_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_TEX_FILTER get_magFilter() { return m_struct.magFilter; }
+ void set_magFilter(XGL_TEX_FILTER inValue) { m_struct.magFilter = inValue; }
+ XGL_TEX_FILTER get_minFilter() { return m_struct.minFilter; }
+ void set_minFilter(XGL_TEX_FILTER inValue) { m_struct.minFilter = inValue; }
+ XGL_TEX_MIPMAP_MODE get_mipMode() { return m_struct.mipMode; }
+ void set_mipMode(XGL_TEX_MIPMAP_MODE inValue) { m_struct.mipMode = inValue; }
+ XGL_TEX_ADDRESS get_addressU() { return m_struct.addressU; }
+ void set_addressU(XGL_TEX_ADDRESS inValue) { m_struct.addressU = inValue; }
+ XGL_TEX_ADDRESS get_addressV() { return m_struct.addressV; }
+ void set_addressV(XGL_TEX_ADDRESS inValue) { m_struct.addressV = inValue; }
+ XGL_TEX_ADDRESS get_addressW() { return m_struct.addressW; }
+ void set_addressW(XGL_TEX_ADDRESS inValue) { m_struct.addressW = inValue; }
+ XGL_FLOAT get_mipLodBias() { return m_struct.mipLodBias; }
+ void set_mipLodBias(XGL_FLOAT inValue) { m_struct.mipLodBias = inValue; }
+ XGL_UINT get_maxAnisotropy() { return m_struct.maxAnisotropy; }
+ void set_maxAnisotropy(XGL_UINT inValue) { m_struct.maxAnisotropy = inValue; }
+ XGL_COMPARE_FUNC get_compareFunc() { return m_struct.compareFunc; }
+ void set_compareFunc(XGL_COMPARE_FUNC inValue) { m_struct.compareFunc = inValue; }
+ XGL_FLOAT get_minLod() { return m_struct.minLod; }
+ void set_minLod(XGL_FLOAT inValue) { m_struct.minLod = inValue; }
+ XGL_FLOAT get_maxLod() { return m_struct.maxLod; }
+ void set_maxLod(XGL_FLOAT inValue) { m_struct.maxLod = inValue; }
+ XGL_BORDER_COLOR_TYPE get_borderColorType() { return m_struct.borderColorType; }
+ void set_borderColorType(XGL_BORDER_COLOR_TYPE inValue) { m_struct.borderColorType = inValue; }
+
+
+private:
+ XGL_SAMPLER_CREATE_INFO m_struct;
+ const XGL_SAMPLER_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_queue_semaphore_create_info_struct_wrapper
+{
+public:
+ xgl_queue_semaphore_create_info_struct_wrapper();
+ xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+ xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_UINT get_initialCount() { return m_struct.initialCount; }
+ void set_initialCount(XGL_UINT inValue) { m_struct.initialCount = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_format_struct_wrapper
+{
+public:
+ xgl_format_struct_wrapper();
+ xgl_format_struct_wrapper(XGL_FORMAT* pInStruct);
+ xgl_format_struct_wrapper(const XGL_FORMAT* pInStruct);
+
+ virtual ~xgl_format_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_CHANNEL_FORMAT get_channelFormat() { return m_struct.channelFormat; }
+ void set_channelFormat(XGL_CHANNEL_FORMAT inValue) { m_struct.channelFormat = inValue; }
+ XGL_NUM_FORMAT get_numericFormat() { return m_struct.numericFormat; }
+ void set_numericFormat(XGL_NUM_FORMAT inValue) { m_struct.numericFormat = inValue; }
+
+
+private:
+ XGL_FORMAT m_struct;
+ const XGL_FORMAT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_state_transition_struct_wrapper
+{
+public:
+ xgl_memory_state_transition_struct_wrapper();
+ xgl_memory_state_transition_struct_wrapper(XGL_MEMORY_STATE_TRANSITION* pInStruct);
+ xgl_memory_state_transition_struct_wrapper(const XGL_MEMORY_STATE_TRANSITION* pInStruct);
+
+ virtual ~xgl_memory_state_transition_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
+ void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
+ XGL_MEMORY_STATE get_oldState() { return m_struct.oldState; }
+ void set_oldState(XGL_MEMORY_STATE inValue) { m_struct.oldState = inValue; }
+ XGL_MEMORY_STATE get_newState() { return m_struct.newState; }
+ void set_newState(XGL_MEMORY_STATE inValue) { m_struct.newState = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_regionSize() { return m_struct.regionSize; }
+ void set_regionSize(XGL_GPU_SIZE inValue) { m_struct.regionSize = inValue; }
+
+
+private:
+ XGL_MEMORY_STATE_TRANSITION m_struct;
+ const XGL_MEMORY_STATE_TRANSITION* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_extent3d_struct_wrapper
+{
+public:
+ xgl_extent3d_struct_wrapper();
+ xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
+ xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
+
+ virtual ~xgl_extent3d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_INT get_width() { return m_struct.width; }
+ void set_width(XGL_INT inValue) { m_struct.width = inValue; }
+ XGL_INT get_height() { return m_struct.height; }
+ void set_height(XGL_INT inValue) { m_struct.height = inValue; }
+ XGL_INT get_depth() { return m_struct.depth; }
+ void set_depth(XGL_INT inValue) { m_struct.depth = inValue; }
+
+
+private:
+ XGL_EXTENT3D m_struct;
+ const XGL_EXTENT3D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_memory_view_slot_info_struct_wrapper
+{
+public:
+ xgl_dynamic_memory_view_slot_info_struct_wrapper();
+ xgl_dynamic_memory_view_slot_info_struct_wrapper(XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* pInStruct);
+ xgl_dynamic_memory_view_slot_info_struct_wrapper(const XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* pInStruct);
+
+ virtual ~xgl_dynamic_memory_view_slot_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_DESCRIPTOR_SET_SLOT_TYPE get_slotObjectType() { return m_struct.slotObjectType; }
+ void set_slotObjectType(XGL_DESCRIPTOR_SET_SLOT_TYPE inValue) { m_struct.slotObjectType = inValue; }
+ XGL_UINT get_shaderEntityIndex() { return m_struct.shaderEntityIndex; }
+ void set_shaderEntityIndex(XGL_UINT inValue) { m_struct.shaderEntityIndex = inValue; }
+
+
+private:
+ XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO m_struct;
+ const XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_view_attach_info_struct_wrapper
+{
+public:
+ xgl_image_view_attach_info_struct_wrapper();
+ xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
+ xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
+
+ virtual ~xgl_image_view_attach_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_IMAGE_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_IMAGE_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_STATE get_state() { return m_struct.state; }
+ void set_state(XGL_IMAGE_STATE inValue) { m_struct.state = inValue; }
+
+
+private:
+ XGL_IMAGE_VIEW_ATTACH_INFO m_struct;
+ const XGL_IMAGE_VIEW_ATTACH_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_subresource_range_struct_wrapper
+{
+public:
+ xgl_image_subresource_range_struct_wrapper();
+ xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+ xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+
+ virtual ~xgl_image_subresource_range_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
+ void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+ XGL_UINT get_baseMipLevel() { return m_struct.baseMipLevel; }
+ void set_baseMipLevel(XGL_UINT inValue) { m_struct.baseMipLevel = inValue; }
+ XGL_UINT get_mipLevels() { return m_struct.mipLevels; }
+ void set_mipLevels(XGL_UINT inValue) { m_struct.mipLevels = inValue; }
+ XGL_UINT get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(XGL_UINT inValue) { m_struct.baseArraySlice = inValue; }
+ XGL_UINT get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(XGL_UINT inValue) { m_struct.arraySize = inValue; }
+
+
+private:
+ XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
+ const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_db_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_db_state_create_info_struct_wrapper();
+ xgl_pipeline_db_state_create_info_struct_wrapper(XGL_PIPELINE_DB_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_db_state_create_info_struct_wrapper(const XGL_PIPELINE_DB_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_db_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+
+
+private:
+ XGL_PIPELINE_DB_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_DB_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_application_info_struct_wrapper
+{
+public:
+ xgl_application_info_struct_wrapper();
+ xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
+ xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
+
+ virtual ~xgl_application_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ const XGL_CHAR* get_pAppName() { return m_struct.pAppName; }
+ XGL_UINT32 get_appVersion() { return m_struct.appVersion; }
+ void set_appVersion(XGL_UINT32 inValue) { m_struct.appVersion = inValue; }
+ const XGL_CHAR* get_pEngineName() { return m_struct.pEngineName; }
+ XGL_UINT32 get_engineVersion() { return m_struct.engineVersion; }
+ void set_engineVersion(XGL_UINT32 inValue) { m_struct.engineVersion = inValue; }
+ XGL_UINT32 get_apiVersion() { return m_struct.apiVersion; }
+ void set_apiVersion(XGL_UINT32 inValue) { m_struct.apiVersion = inValue; }
+
+
+private:
+ XGL_APPLICATION_INFO m_struct;
+ const XGL_APPLICATION_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_offset2d_struct_wrapper
+{
+public:
+ xgl_offset2d_struct_wrapper();
+ xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
+ xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
+
+ virtual ~xgl_offset2d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_INT get_x() { return m_struct.x; }
+ void set_x(XGL_INT inValue) { m_struct.x = inValue; }
+ XGL_INT get_y() { return m_struct.y; }
+ void set_y(XGL_INT inValue) { m_struct.y = inValue; }
+
+
+private:
+ XGL_OFFSET2D m_struct;
+ const XGL_OFFSET2D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_viewport_state_create_info_struct_wrapper
+{
+public:
+ xgl_viewport_state_create_info_struct_wrapper();
+ xgl_viewport_state_create_info_struct_wrapper(XGL_VIEWPORT_STATE_CREATE_INFO* pInStruct);
+ xgl_viewport_state_create_info_struct_wrapper(const XGL_VIEWPORT_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_viewport_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT get_viewportCount() { return m_struct.viewportCount; }
+ void set_viewportCount(XGL_UINT inValue) { m_struct.viewportCount = inValue; }
+ XGL_BOOL get_scissorEnable() { return m_struct.scissorEnable; }
+ void set_scissorEnable(XGL_BOOL inValue) { m_struct.scissorEnable = inValue; }
+
+
+private:
+ XGL_VIEWPORT_STATE_CREATE_INFO m_struct;
+ const XGL_VIEWPORT_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_state_transition_struct_wrapper
+{
+public:
+ xgl_image_state_transition_struct_wrapper();
+ xgl_image_state_transition_struct_wrapper(XGL_IMAGE_STATE_TRANSITION* pInStruct);
+ xgl_image_state_transition_struct_wrapper(const XGL_IMAGE_STATE_TRANSITION* pInStruct);
+
+ virtual ~xgl_image_state_transition_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_IMAGE_STATE get_oldState() { return m_struct.oldState; }
+ void set_oldState(XGL_IMAGE_STATE inValue) { m_struct.oldState = inValue; }
+ XGL_IMAGE_STATE get_newState() { return m_struct.newState; }
+ void set_newState(XGL_IMAGE_STATE inValue) { m_struct.newState = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+ void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+
+
+private:
+ XGL_IMAGE_STATE_TRANSITION m_struct;
+ const XGL_IMAGE_STATE_TRANSITION* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_device_create_info_struct_wrapper
+{
+public:
+ xgl_device_create_info_struct_wrapper();
+ xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
+ xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_device_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_UINT get_queueRecordCount() { return m_struct.queueRecordCount; }
+ void set_queueRecordCount(XGL_UINT inValue) { m_struct.queueRecordCount = inValue; }
+ const XGL_DEVICE_QUEUE_CREATE_INFO* get_pRequestedQueues() { return m_struct.pRequestedQueues; }
+ XGL_UINT get_extensionCount() { return m_struct.extensionCount; }
+ void set_extensionCount(XGL_UINT inValue) { m_struct.extensionCount = inValue; }
+ const XGL_CHAR*const* get_ppEnabledExtensionNames() { return m_struct.ppEnabledExtensionNames; }
+ XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
+ void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_DEVICE_CREATE_INFO m_struct;
+ const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_create_info_struct_wrapper
+{
+public:
+ xgl_image_create_info_struct_wrapper();
+ xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
+ xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_image_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
+ void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+ XGL_UINT get_mipLevels() { return m_struct.mipLevels; }
+ void set_mipLevels(XGL_UINT inValue) { m_struct.mipLevels = inValue; }
+ XGL_UINT get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(XGL_UINT inValue) { m_struct.arraySize = inValue; }
+ XGL_UINT get_samples() { return m_struct.samples; }
+ void set_samples(XGL_UINT inValue) { m_struct.samples = inValue; }
+ XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
+ void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_IMAGE_CREATE_INFO m_struct;
+ const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_rect_struct_wrapper
+{
+public:
+ xgl_rect_struct_wrapper();
+ xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
+ xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
+
+ virtual ~xgl_rect_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_OFFSET2D get_offset() { return m_struct.offset; }
+ void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
+ XGL_EXTENT2D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_RECT m_struct;
+ const XGL_RECT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_copy_struct_wrapper
+{
+public:
+ xgl_memory_copy_struct_wrapper();
+ xgl_memory_copy_struct_wrapper(XGL_MEMORY_COPY* pInStruct);
+ xgl_memory_copy_struct_wrapper(const XGL_MEMORY_COPY* pInStruct);
+
+ virtual ~xgl_memory_copy_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_SIZE get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_GPU_SIZE inValue) { m_struct.srcOffset = inValue; }
+ XGL_GPU_SIZE get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_GPU_SIZE inValue) { m_struct.destOffset = inValue; }
+ XGL_GPU_SIZE get_copySize() { return m_struct.copySize; }
+ void set_copySize(XGL_GPU_SIZE inValue) { m_struct.copySize = inValue; }
+
+
+private:
+ XGL_MEMORY_COPY m_struct;
+ const XGL_MEMORY_COPY* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_slot_info_struct_wrapper
+{
+public:
+ xgl_descriptor_slot_info_struct_wrapper();
+ xgl_descriptor_slot_info_struct_wrapper(XGL_DESCRIPTOR_SLOT_INFO* pInStruct);
+ xgl_descriptor_slot_info_struct_wrapper(const XGL_DESCRIPTOR_SLOT_INFO* pInStruct);
+
+ virtual ~xgl_descriptor_slot_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_DESCRIPTOR_SET_SLOT_TYPE get_slotObjectType() { return m_struct.slotObjectType; }
+ void set_slotObjectType(XGL_DESCRIPTOR_SET_SLOT_TYPE inValue) { m_struct.slotObjectType = inValue; }
+ XGL_UINT get_shaderEntityIndex() { return m_struct.shaderEntityIndex; }
+ void set_shaderEntityIndex(XGL_UINT inValue) { m_struct.shaderEntityIndex = inValue; }
+ const struct _XGL_DESCRIPTOR_SET_MAPPING* get_pNextLevelSet() { return m_struct.pNextLevelSet; }
+
+
+private:
+ XGL_DESCRIPTOR_SLOT_INFO m_struct;
+ const XGL_DESCRIPTOR_SLOT_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_link_const_buffer_struct_wrapper
+{
+public:
+ xgl_link_const_buffer_struct_wrapper();
+ xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
+ xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
+
+ virtual ~xgl_link_const_buffer_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT get_bufferId() { return m_struct.bufferId; }
+ void set_bufferId(XGL_UINT inValue) { m_struct.bufferId = inValue; }
+ XGL_SIZE get_bufferSize() { return m_struct.bufferSize; }
+ void set_bufferSize(XGL_SIZE inValue) { m_struct.bufferSize = inValue; }
+ const XGL_VOID* get_pBufferData() { return m_struct.pBufferData; }
+
+
+private:
+ XGL_LINK_CONST_BUFFER m_struct;
+ const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_image_copy_struct_wrapper
+{
+public:
+ xgl_memory_image_copy_struct_wrapper();
+ xgl_memory_image_copy_struct_wrapper(XGL_MEMORY_IMAGE_COPY* pInStruct);
+ xgl_memory_image_copy_struct_wrapper(const XGL_MEMORY_IMAGE_COPY* pInStruct);
+
+ virtual ~xgl_memory_image_copy_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_SIZE get_memOffset() { return m_struct.memOffset; }
+ void set_memOffset(XGL_GPU_SIZE inValue) { m_struct.memOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
+ void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
+ XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
+ void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
+ XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
+ void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
+
+
+private:
+ XGL_MEMORY_IMAGE_COPY m_struct;
+ const XGL_MEMORY_IMAGE_COPY* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_state_create_info_struct_wrapper
+{
+public:
+ xgl_depth_stencil_state_create_info_struct_wrapper();
+ xgl_depth_stencil_state_create_info_struct_wrapper(XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pInStruct);
+ xgl_depth_stencil_state_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_depth_stencil_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_BOOL get_depthTestEnable() { return m_struct.depthTestEnable; }
+ void set_depthTestEnable(XGL_BOOL inValue) { m_struct.depthTestEnable = inValue; }
+ XGL_BOOL get_depthWriteEnable() { return m_struct.depthWriteEnable; }
+ void set_depthWriteEnable(XGL_BOOL inValue) { m_struct.depthWriteEnable = inValue; }
+ XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
+ void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
+ XGL_BOOL get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
+ void set_depthBoundsEnable(XGL_BOOL inValue) { m_struct.depthBoundsEnable = inValue; }
+ XGL_FLOAT get_minDepth() { return m_struct.minDepth; }
+ void set_minDepth(XGL_FLOAT inValue) { m_struct.minDepth = inValue; }
+ XGL_FLOAT get_maxDepth() { return m_struct.maxDepth; }
+ void set_maxDepth(XGL_FLOAT inValue) { m_struct.maxDepth = inValue; }
+ XGL_BOOL get_stencilTestEnable() { return m_struct.stencilTestEnable; }
+ void set_stencilTestEnable(XGL_BOOL inValue) { m_struct.stencilTestEnable = inValue; }
+ XGL_UINT32 get_stencilReadMask() { return m_struct.stencilReadMask; }
+ void set_stencilReadMask(XGL_UINT32 inValue) { m_struct.stencilReadMask = inValue; }
+ XGL_UINT32 get_stencilWriteMask() { return m_struct.stencilWriteMask; }
+ void set_stencilWriteMask(XGL_UINT32 inValue) { m_struct.stencilWriteMask = inValue; }
+ XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
+ void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
+ XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
+ void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
+
+
+private:
+ XGL_DEPTH_STENCIL_STATE_CREATE_INFO m_struct;
+ const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_viewport_struct_wrapper
+{
+public:
+ xgl_viewport_struct_wrapper();
+ xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
+ xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
+
+ virtual ~xgl_viewport_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_FLOAT get_originX() { return m_struct.originX; }
+ void set_originX(XGL_FLOAT inValue) { m_struct.originX = inValue; }
+ XGL_FLOAT get_originY() { return m_struct.originY; }
+ void set_originY(XGL_FLOAT inValue) { m_struct.originY = inValue; }
+ XGL_FLOAT get_width() { return m_struct.width; }
+ void set_width(XGL_FLOAT inValue) { m_struct.width = inValue; }
+ XGL_FLOAT get_height() { return m_struct.height; }
+ void set_height(XGL_FLOAT inValue) { m_struct.height = inValue; }
+ XGL_FLOAT get_minDepth() { return m_struct.minDepth; }
+ void set_minDepth(XGL_FLOAT inValue) { m_struct.minDepth = inValue; }
+ XGL_FLOAT get_maxDepth() { return m_struct.maxDepth; }
+ void set_maxDepth(XGL_FLOAT inValue) { m_struct.maxDepth = inValue; }
+
+
+private:
+ XGL_VIEWPORT m_struct;
+ const XGL_VIEWPORT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_set_mapping_struct_wrapper
+{
+public:
+ xgl_descriptor_set_mapping_struct_wrapper();
+ xgl_descriptor_set_mapping_struct_wrapper(XGL_DESCRIPTOR_SET_MAPPING* pInStruct);
+ xgl_descriptor_set_mapping_struct_wrapper(const XGL_DESCRIPTOR_SET_MAPPING* pInStruct);
+
+ virtual ~xgl_descriptor_set_mapping_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT get_descriptorCount() { return m_struct.descriptorCount; }
+ void set_descriptorCount(XGL_UINT inValue) { m_struct.descriptorCount = inValue; }
+ const XGL_DESCRIPTOR_SLOT_INFO* get_pDescriptorInfo() { return m_struct.pDescriptorInfo; }
+
+
+private:
+ XGL_DESCRIPTOR_SET_MAPPING m_struct;
+ const XGL_DESCRIPTOR_SET_MAPPING* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_peer_memory_open_info_struct_wrapper
+{
+public:
+ xgl_peer_memory_open_info_struct_wrapper();
+ xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+ xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_peer_memory_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
+ void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
+
+
+private:
+ XGL_PEER_MEMORY_OPEN_INFO m_struct;
+ const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_subresource_layout_struct_wrapper
+{
+public:
+ xgl_subresource_layout_struct_wrapper();
+ xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct);
+ xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct);
+
+ virtual ~xgl_subresource_layout_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+ XGL_GPU_SIZE get_rowPitch() { return m_struct.rowPitch; }
+ void set_rowPitch(XGL_GPU_SIZE inValue) { m_struct.rowPitch = inValue; }
+ XGL_GPU_SIZE get_depthPitch() { return m_struct.depthPitch; }
+ void set_depthPitch(XGL_GPU_SIZE inValue) { m_struct.depthPitch = inValue; }
+
+
+private:
+ XGL_SUBRESOURCE_LAYOUT m_struct;
+ const XGL_SUBRESOURCE_LAYOUT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_set_attach_info_struct_wrapper
+{
+public:
+ xgl_descriptor_set_attach_info_struct_wrapper();
+ xgl_descriptor_set_attach_info_struct_wrapper(XGL_DESCRIPTOR_SET_ATTACH_INFO* pInStruct);
+ xgl_descriptor_set_attach_info_struct_wrapper(const XGL_DESCRIPTOR_SET_ATTACH_INFO* pInStruct);
+
+ virtual ~xgl_descriptor_set_attach_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
+ void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
+ XGL_UINT get_slotOffset() { return m_struct.slotOffset; }
+ void set_slotOffset(XGL_UINT inValue) { m_struct.slotOffset = inValue; }
+
+
+private:
+ XGL_DESCRIPTOR_SET_ATTACH_INFO m_struct;
+ const XGL_DESCRIPTOR_SET_ATTACH_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_tess_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_tess_state_create_info_struct_wrapper();
+ xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_UINT get_patchControlPoints() { return m_struct.patchControlPoints; }
+ void set_patchControlPoints(XGL_UINT inValue) { m_struct.patchControlPoints = inValue; }
+ XGL_FLOAT get_optimalTessFactor() { return m_struct.optimalTessFactor; }
+ void set_optimalTessFactor(XGL_FLOAT inValue) { m_struct.optimalTessFactor = inValue; }
+ XGL_FLOAT get_fixedTessFactor() { return m_struct.fixedTessFactor; }
+ void set_fixedTessFactor(XGL_FLOAT inValue) { m_struct.fixedTessFactor = inValue; }
+
+
+private:
+ XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_rs_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_rs_state_create_info_struct_wrapper();
+ xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_BOOL get_depthClipEnable() { return m_struct.depthClipEnable; }
+ void set_depthClipEnable(XGL_BOOL inValue) { m_struct.depthClipEnable = inValue; }
+ XGL_BOOL get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
+ void set_rasterizerDiscardEnable(XGL_BOOL inValue) { m_struct.rasterizerDiscardEnable = inValue; }
+ XGL_FLOAT get_pointSize() { return m_struct.pointSize; }
+ void set_pointSize(XGL_FLOAT inValue) { m_struct.pointSize = inValue; }
+
+
+private:
+ XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_stencil_op_state_struct_wrapper
+{
+public:
+ xgl_stencil_op_state_struct_wrapper();
+ xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
+ xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
+
+ virtual ~xgl_stencil_op_state_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
+ void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
+ XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
+ void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
+ XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
+ void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
+ XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
+ void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
+ XGL_UINT32 get_stencilRef() { return m_struct.stencilRef; }
+ void set_stencilRef(XGL_UINT32 inValue) { m_struct.stencilRef = inValue; }
+
+
+private:
+ XGL_STENCIL_OP_STATE m_struct;
+ const XGL_STENCIL_OP_STATE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_shader_create_info_struct_wrapper
+{
+public:
+ xgl_shader_create_info_struct_wrapper();
+ xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
+ xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_shader_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_SIZE get_codeSize() { return m_struct.codeSize; }
+ void set_codeSize(XGL_SIZE inValue) { m_struct.codeSize = inValue; }
+ const XGL_VOID* get_pCode() { return m_struct.pCode; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_SHADER_CREATE_INFO m_struct;
+ const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_blend_state_create_info_struct_wrapper
+{
+public:
+ xgl_color_blend_state_create_info_struct_wrapper();
+ xgl_color_blend_state_create_info_struct_wrapper(XGL_COLOR_BLEND_STATE_CREATE_INFO* pInStruct);
+ xgl_color_blend_state_create_info_struct_wrapper(const XGL_COLOR_BLEND_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_color_blend_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+
+
+private:
+ XGL_COLOR_BLEND_STATE_CREATE_INFO m_struct;
+ const XGL_COLOR_BLEND_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_cb_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_cb_state_create_info_struct_wrapper();
+ xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE* pInStruct);
+ xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE* pInStruct);
+
+ virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_BOOL get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
+ void set_alphaToCoverageEnable(XGL_BOOL inValue) { m_struct.alphaToCoverageEnable = inValue; }
+ XGL_BOOL get_dualSourceBlendEnable() { return m_struct.dualSourceBlendEnable; }
+ void set_dualSourceBlendEnable(XGL_BOOL inValue) { m_struct.dualSourceBlendEnable = inValue; }
+ XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
+ void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
+
+
+private:
+ XGL_PIPELINE_CB_STATE m_struct;
+ const XGL_PIPELINE_CB_STATE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_channel_mapping_struct_wrapper
+{
+public:
+ xgl_channel_mapping_struct_wrapper();
+ xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
+ xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
+
+ virtual ~xgl_channel_mapping_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
+ void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
+ XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
+ void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
+ XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
+ void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
+ XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
+ void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
+
+
+private:
+ XGL_CHANNEL_MAPPING m_struct;
+ const XGL_CHANNEL_MAPPING* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_view_create_info_struct_wrapper
+{
+public:
+ xgl_depth_stencil_view_create_info_struct_wrapper();
+ xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+ xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_UINT get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(XGL_UINT inValue) { m_struct.mipLevel = inValue; }
+ XGL_UINT get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(XGL_UINT inValue) { m_struct.baseArraySlice = inValue; }
+ XGL_UINT get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(XGL_UINT inValue) { m_struct.arraySize = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_virtual_memory_remap_range_struct_wrapper
+{
+public:
+ xgl_virtual_memory_remap_range_struct_wrapper();
+ xgl_virtual_memory_remap_range_struct_wrapper(XGL_VIRTUAL_MEMORY_REMAP_RANGE* pInStruct);
+ xgl_virtual_memory_remap_range_struct_wrapper(const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pInStruct);
+
+ virtual ~xgl_virtual_memory_remap_range_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_MEMORY get_virtualMem() { return m_struct.virtualMem; }
+ void set_virtualMem(XGL_GPU_MEMORY inValue) { m_struct.virtualMem = inValue; }
+ XGL_GPU_SIZE get_virtualStartPage() { return m_struct.virtualStartPage; }
+ void set_virtualStartPage(XGL_GPU_SIZE inValue) { m_struct.virtualStartPage = inValue; }
+ XGL_GPU_MEMORY get_realMem() { return m_struct.realMem; }
+ void set_realMem(XGL_GPU_MEMORY inValue) { m_struct.realMem = inValue; }
+ XGL_GPU_SIZE get_realStartPage() { return m_struct.realStartPage; }
+ void set_realStartPage(XGL_GPU_SIZE inValue) { m_struct.realStartPage = inValue; }
+ XGL_GPU_SIZE get_pageCount() { return m_struct.pageCount; }
+ void set_pageCount(XGL_GPU_SIZE inValue) { m_struct.pageCount = inValue; }
+
+
+private:
+ XGL_VIRTUAL_MEMORY_REMAP_RANGE m_struct;
+ const XGL_VIRTUAL_MEMORY_REMAP_RANGE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_create_info_struct_wrapper
+{
+public:
+ xgl_cmd_buffer_create_info_struct_wrapper();
+ xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+ xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
+ void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_CMD_BUFFER_CREATE_INFO m_struct;
+ const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_format_properties_struct_wrapper
+{
+public:
+ xgl_format_properties_struct_wrapper();
+ xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct);
+ xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct);
+
+ virtual ~xgl_format_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
+ void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
+ XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
+ void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
+
+
+private:
+ XGL_FORMAT_PROPERTIES m_struct;
+ const XGL_FORMAT_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_properties_struct_wrapper
+{
+public:
+ xgl_physical_gpu_properties_struct_wrapper();
+ xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
+ xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
+
+ virtual ~xgl_physical_gpu_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_SIZE get_structSize() { return m_struct.structSize; }
+ void set_structSize(XGL_SIZE inValue) { m_struct.structSize = inValue; }
+ XGL_UINT32 get_apiVersion() { return m_struct.apiVersion; }
+ void set_apiVersion(XGL_UINT32 inValue) { m_struct.apiVersion = inValue; }
+ XGL_UINT32 get_driverVersion() { return m_struct.driverVersion; }
+ void set_driverVersion(XGL_UINT32 inValue) { m_struct.driverVersion = inValue; }
+ XGL_UINT32 get_vendorId() { return m_struct.vendorId; }
+ void set_vendorId(XGL_UINT32 inValue) { m_struct.vendorId = inValue; }
+ XGL_UINT32 get_deviceId() { return m_struct.deviceId; }
+ void set_deviceId(XGL_UINT32 inValue) { m_struct.deviceId = inValue; }
+ XGL_PHYSICAL_GPU_TYPE get_gpuType() { return m_struct.gpuType; }
+ void set_gpuType(XGL_PHYSICAL_GPU_TYPE inValue) { m_struct.gpuType = inValue; }
+ XGL_UINT get_maxMemRefsPerSubmission() { return m_struct.maxMemRefsPerSubmission; }
+ void set_maxMemRefsPerSubmission(XGL_UINT inValue) { m_struct.maxMemRefsPerSubmission = inValue; }
+ XGL_GPU_SIZE get_virtualMemPageSize() { return m_struct.virtualMemPageSize; }
+ void set_virtualMemPageSize(XGL_GPU_SIZE inValue) { m_struct.virtualMemPageSize = inValue; }
+ XGL_GPU_SIZE get_maxInlineMemoryUpdateSize() { return m_struct.maxInlineMemoryUpdateSize; }
+ void set_maxInlineMemoryUpdateSize(XGL_GPU_SIZE inValue) { m_struct.maxInlineMemoryUpdateSize = inValue; }
+ XGL_UINT get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; }
+ void set_maxBoundDescriptorSets(XGL_UINT inValue) { m_struct.maxBoundDescriptorSets = inValue; }
+ XGL_UINT get_maxThreadGroupSize() { return m_struct.maxThreadGroupSize; }
+ void set_maxThreadGroupSize(XGL_UINT inValue) { m_struct.maxThreadGroupSize = inValue; }
+ XGL_UINT64 get_timestampFrequency() { return m_struct.timestampFrequency; }
+ void set_timestampFrequency(XGL_UINT64 inValue) { m_struct.timestampFrequency = inValue; }
+ XGL_BOOL get_multiColorAttachmentClears() { return m_struct.multiColorAttachmentClears; }
+ void set_multiColorAttachmentClears(XGL_BOOL inValue) { m_struct.multiColorAttachmentClears = inValue; }
+
+
+private:
+ XGL_PHYSICAL_GPU_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_bind_info_struct_wrapper
+{
+public:
+ xgl_depth_stencil_bind_info_struct_wrapper();
+ xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+ xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+
+ virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_STATE get_depthState() { return m_struct.depthState; }
+ void set_depthState(XGL_IMAGE_STATE inValue) { m_struct.depthState = inValue; }
+ XGL_IMAGE_STATE get_stencilState() { return m_struct.stencilState; }
+ void set_stencilState(XGL_IMAGE_STATE inValue) { m_struct.stencilState = inValue; }
+
+
+private:
+ XGL_DEPTH_STENCIL_BIND_INFO m_struct;
+ const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_draw_indirect_cmd_struct_wrapper
+{
+public:
+ xgl_draw_indirect_cmd_struct_wrapper();
+ xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
+ xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
+
+ virtual ~xgl_draw_indirect_cmd_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT32 get_vertexCount() { return m_struct.vertexCount; }
+ void set_vertexCount(XGL_UINT32 inValue) { m_struct.vertexCount = inValue; }
+ XGL_UINT32 get_instanceCount() { return m_struct.instanceCount; }
+ void set_instanceCount(XGL_UINT32 inValue) { m_struct.instanceCount = inValue; }
+ XGL_UINT32 get_firstVertex() { return m_struct.firstVertex; }
+ void set_firstVertex(XGL_UINT32 inValue) { m_struct.firstVertex = inValue; }
+ XGL_UINT32 get_firstInstance() { return m_struct.firstInstance; }
+ void set_firstInstance(XGL_UINT32 inValue) { m_struct.firstInstance = inValue; }
+
+
+private:
+ XGL_DRAW_INDIRECT_CMD m_struct;
+ const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_graphics_pipeline_create_info_struct_wrapper
+{
+public:
+ xgl_graphics_pipeline_create_info_struct_wrapper();
+ xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_ia_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_ia_state_create_info_struct_wrapper();
+ xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
+ void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
+ XGL_BOOL get_disableVertexReuse() { return m_struct.disableVertexReuse; }
+ void set_disableVertexReuse(XGL_BOOL inValue) { m_struct.disableVertexReuse = inValue; }
+ XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
+ void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
+ XGL_BOOL get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
+ void set_primitiveRestartEnable(XGL_BOOL inValue) { m_struct.primitiveRestartEnable = inValue; }
+ XGL_UINT32 get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
+ void set_primitiveRestartIndex(XGL_UINT32 inValue) { m_struct.primitiveRestartIndex = inValue; }
+
+
+private:
+ XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_blend_state_struct_wrapper
+{
+public:
+ xgl_color_attachment_blend_state_struct_wrapper();
+ xgl_color_attachment_blend_state_struct_wrapper(XGL_COLOR_ATTACHMENT_BLEND_STATE* pInStruct);
+ xgl_color_attachment_blend_state_struct_wrapper(const XGL_COLOR_ATTACHMENT_BLEND_STATE* pInStruct);
+
+ virtual ~xgl_color_attachment_blend_state_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_BOOL get_blendEnable() { return m_struct.blendEnable; }
+ void set_blendEnable(XGL_BOOL inValue) { m_struct.blendEnable = inValue; }
+ XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
+ void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
+ XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
+ void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
+ XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
+ void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
+ XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
+ void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
+ XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
+ void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
+ XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
+ void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
+
+
+private:
+ XGL_COLOR_ATTACHMENT_BLEND_STATE m_struct;
+ const XGL_COLOR_ATTACHMENT_BLEND_STATE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_extent2d_struct_wrapper
+{
+public:
+ xgl_extent2d_struct_wrapper();
+ xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
+ xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
+
+ virtual ~xgl_extent2d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_INT get_width() { return m_struct.width; }
+ void set_width(XGL_INT inValue) { m_struct.width = inValue; }
+ XGL_INT get_height() { return m_struct.height; }
+ void set_height(XGL_INT inValue) { m_struct.height = inValue; }
+
+
+private:
+ XGL_EXTENT2D m_struct;
+ const XGL_EXTENT2D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_alloc_info_struct_wrapper
+{
+public:
+ xgl_memory_alloc_info_struct_wrapper();
+ xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
+ xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
+
+ virtual ~xgl_memory_alloc_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
+ void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
+ XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
+ void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_UINT get_heapCount() { return m_struct.heapCount; }
+ void set_heapCount(XGL_UINT inValue) { m_struct.heapCount = inValue; }
+ XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
+ void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
+
+
+private:
+ XGL_MEMORY_ALLOC_INFO m_struct;
+ const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_ref_struct_wrapper
+{
+public:
+ xgl_memory_ref_struct_wrapper();
+ xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
+ xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
+
+ virtual ~xgl_memory_ref_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
+ void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_MEMORY_REF m_struct;
+ const XGL_MEMORY_REF* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_query_pool_create_info_struct_wrapper
+{
+public:
+ xgl_query_pool_create_info_struct_wrapper();
+ xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+ xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_query_pool_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
+ void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
+ XGL_UINT get_slots() { return m_struct.slots; }
+ void set_slots(XGL_UINT inValue) { m_struct.slots = inValue; }
+
+
+private:
+ XGL_QUERY_POOL_CREATE_INFO m_struct;
+ const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_offset3d_struct_wrapper
+{
+public:
+ xgl_offset3d_struct_wrapper();
+ xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
+ xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+
+ virtual ~xgl_offset3d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_INT get_x() { return m_struct.x; }
+ void set_x(XGL_INT inValue) { m_struct.x = inValue; }
+ XGL_INT get_y() { return m_struct.y; }
+ void set_y(XGL_INT inValue) { m_struct.y = inValue; }
+ XGL_INT get_z() { return m_struct.z; }
+ void set_z(XGL_INT inValue) { m_struct.z = inValue; }
+
+
+private:
+ XGL_OFFSET3D m_struct;
+ const XGL_OFFSET3D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_shader_stage_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_shader_stage_create_info_struct_wrapper();
+ xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+ xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const XGL_VOID* get_pNext() { return m_struct.pNext; }
+ XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
+ void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
+
+
+private:
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_view_attach_info_struct_wrapper
+{
+public:
+ xgl_memory_view_attach_info_struct_wrapper();
+ xgl_memory_view_attach_info_struct_wrapper(XGL_MEMORY_VIEW_ATTACH_INFO* pInStruct);
+ xgl_memory_view_attach_info_struct_wrapper(const XGL_MEMORY_VIEW_ATTACH_INFO* pInStruct);
+
+ virtual ~xgl_memory_view_attach_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ XGL_VOID* get_pNext() { return m_struct.pNext; }
+ void set_pNext(XGL_VOID* inValue) { m_struct.pNext = inValue; }
+ XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
+ void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_range() { return m_struct.range; }
+ void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
+ XGL_GPU_SIZE get_stride() { return m_struct.stride; }
+ void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_MEMORY_STATE get_state() { return m_struct.state; }
+ void set_state(XGL_MEMORY_STATE inValue) { m_struct.state = inValue; }
+
+
+private:
+ XGL_MEMORY_VIEW_ATTACH_INFO m_struct;
+ const XGL_MEMORY_VIEW_ATTACH_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dispatch_indirect_cmd_struct_wrapper
+{
+public:
+ xgl_dispatch_indirect_cmd_struct_wrapper();
+ xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+ xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+
+ virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_UINT32 get_x() { return m_struct.x; }
+ void set_x(XGL_UINT32 inValue) { m_struct.x = inValue; }
+ XGL_UINT32 get_y() { return m_struct.y; }
+ void set_y(XGL_UINT32 inValue) { m_struct.y = inValue; }
+ XGL_UINT32 get_z() { return m_struct.z; }
+ void set_z(XGL_UINT32 inValue) { m_struct.z = inValue; }
+
+
+private:
+ XGL_DISPATCH_INDIRECT_CMD m_struct;
+ const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+//any footer info for class
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
new file mode 100644
index 0000000..80a813a
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
@@ -0,0 +1,53 @@
+cmake_minimum_required(VERSION 2.8)
+
+# this project is currently only available on Linux
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+
+project(glvreplay_xgl)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/thirdparty/xgl/inc/)
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+set(OS_REPLAYER_LIBS
+ ${SRC_DIR}/thirdparty/xgl/lib/xgl64.lib
+)
+endif()
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+set(OS_REPLAYER_LIBS
+ ${SRC_DIR}/thirdparty/xgl/lib/libXGL.so
+ xcb
+)
+endif()
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glvreplay_xgl.cpp
+ glvreplay_xgl_replay.cpp
+)
+
+set (HDR_LIST
+ glvreplay_xgl.h
+ glvreplay_xgl_replay.h
+)
+
+include_directories(
+ ${SRC_DIR}/glvreplay
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/thirdparty
+ ${SRC_DIR}/glv_extensions/glvtrace_xgl
+)
+
+add_library(${PROJECT_NAME} SHARED ${SRC_LIST} ${HDR_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+ ${OS_REPLAYER_LIBS}
+ getopt_bundled
+ glvcommon
+)
+
+build_options_finalize()
+
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
new file mode 100644
index 0000000..c555681
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
@@ -0,0 +1,64 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glvreplay_xgl.h"
+#include "glvreplay_xgl_replay.h"
+
+ApiReplay* g_pReplayer = NULL;
+
+GLVTRACER_EXPORT int GLVTRACER_STDCALL Initialize(glv_replay::Display* pDisplay, unsigned int debugLevel)
+{
+ try
+ {
+ g_pReplayer = (ApiReplay*)new xglReplay(debugLevel);
+ }
+ catch (int e)
+ {
+ glv_LogError("Failed to create xglReplay, probably out of memory. Error %d\n", e);
+ return -1;
+ }
+
+ int result = g_pReplayer->init(*pDisplay);
+ return result;
+}
+
+GLVTRACER_EXPORT void GLVTRACER_STDCALL Deinitialize()
+{
+ if (g_pReplayer != NULL)
+ {
+ delete g_pReplayer;
+ g_pReplayer = NULL;
+ }
+}
+
+GLVTRACER_EXPORT glv_replay::GLV_REPLAY_RESULT GLVTRACER_STDCALL Replay(glv_trace_packet_header* pPacket)
+{
+ glv_replay::GLV_REPLAY_RESULT result = glv_replay::GLV_REPLAY_ERROR;
+ if (g_pReplayer != NULL)
+ {
+ result = g_pReplayer->replay(pPacket);
+ }
+ return result;
+}
+
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.h b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.h
new file mode 100644
index 0000000..f503339
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.h
@@ -0,0 +1,34 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+#include "glvreplay_window.h"
+#include "glvreplay_factory.h"
+
+extern "C"
+{
+GLVTRACER_EXPORT int GLVTRACER_STDCALL Initialize(glv_replay::Display* pDisplay, unsigned int debugLevel);
+GLVTRACER_EXPORT void GLVTRACER_STDCALL Deinitialize();
+GLVTRACER_EXPORT glv_replay::GLV_REPLAY_RESULT GLVTRACER_STDCALL Replay(glv_trace_packet_header* pPacket);
+}
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_replay.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_replay.cpp
new file mode 100644
index 0000000..acd771b
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_replay.cpp
@@ -0,0 +1,1931 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glvreplay_xgl_replay.h"
+
+
+extern "C" {
+#include "glvtrace_xgl_xgl_structs.h"
+#include "glvtrace_xgl_xgldbg_structs.h"
+#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glvtrace_xgl_packet_id.h"
+}
+
+#define APP_NAME "glvreplay_xgl"
+#define IDI_ICON 101
+
+static const char* g_extensions[] =
+{
+ "XGL_WSI_WINDOWS",
+ "XGL_TIMER_QUEUE",
+ "XGL_GPU_TIMESTAMP_CALIBRATION",
+ "XGL_DMA_QUEUE",
+ "XGL_COMMAND_BUFFER_CONTROL_FLOW",
+ "XGL_COPY_OCCLUSION_QUERY_DATA",
+ "XGL_ADVANCED_MULTISAMPLING",
+ "XGL_BORDER_COLOR_PALETTE"
+};
+
+XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)
+{
+#if 0
+ XGL_APPLICATION_INFO appInfo = {};
+ appInfo.pAppName = APP_NAME;
+ appInfo.pEngineName = "";
+ appInfo.apiVersion = XGL_API_VERSION;
+
+ XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);
+
+ if ( res == XGL_SUCCESS ) {
+ // retrieve the GPU information for all GPUs
+ for( XGL_UINT32 gpu = 0; gpu < m_gpuCount; gpu++)
+ {
+ XGL_SIZE gpuInfoSize = sizeof(m_gpuProps[0]);
+
+ // get the GPU physical properties:
+ res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);
+ if (res != XGL_SUCCESS)
+ glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\n", gpu, res);
+ }
+ res = XGL_SUCCESS;
+ } else if ((gpu_idx + 1) > m_gpuCount) {
+ glv_LogError("xglInitAndEnumerate number of gpus doesn't include requested index: num %d, requested %d\n", m_gpuCount, gpu_idx);
+ return -1;
+ } else {
+ glv_LogError("xglInitAndEnumerate failed");
+ return res;
+ }
+
+ // TODO add multi-gpu support always use gpu[gpu_idx] for now
+
+ // get all extensions supported by this device gpu[gpu_idx]
+ // first check if extensions are available and save a list of them
+ bool foundWSIExt = false;
+ for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)
+ {
+ res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );
+ if (res == XGL_SUCCESS) {
+ m_extensions.push_back((XGL_CHAR *) extensions[ext]);
+ if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))
+ foundWSIExt = true;
+ }
+ }
+
+ if (!foundWSIExt) {
+ glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\n", gpu_idx);
+ return XGL_ERROR_INCOMPATIBLE_DEVICE;
+ }
+
+ // TODO generalize this: use one universal queue for now
+ XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};
+ dqci.queueCount = 1;
+ dqci.queueType = XGL_QUEUE_UNIVERSAL;
+
+ // create the device enabling validation level 4
+ const XGL_CHAR * const * extNames = &m_extensions[0];
+ XGL_DEVICE_CREATE_INFO info = {};
+ info.queueRecordCount = 1;
+ info.pRequestedQueues = &dqci;
+ info.extensionCount = static_cast <XGL_UINT> (m_extensions.size());
+ info.ppEnabledExtensionNames = extNames;
+ info.flags = XGL_DEVICE_CREATE_VALIDATION;
+ info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;
+ XGL_BOOL xglTrue = XGL_TRUE;
+ res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );
+ if (res != XGL_SUCCESS)
+ glv_LogWarn("Couldn't set debug option break on error\n");
+ res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);
+ return res;
+#else
+ return XGL_ERROR_INITIALIZATION_FAILED;
+#endif
+}
+
+int xglDisplay::init(const unsigned int gpu_idx)
+{
+
+ //m_gpuIdx = gpu_idx;
+#if 0
+ XGL_RESULT result = init_xgl(gpu_idx);
+ if (result != XGL_SUCCESS) {
+ glv_LogError("couldn't init xgl library");
+ return -1;
+ } else {
+ m_initedXGL = true;
+ }
+#endif
+#if defined(PLATFORM_LINUX)
+
+ const xcb_setup_t *setup;
+ xcb_screen_iterator_t iter;
+ int scr;
+ xcb_connection_t *pConnection;
+
+ pConnection = xcb_connect(NULL, &scr);
+
+ setup = xcb_get_setup(pConnection);
+ iter = xcb_setup_roots_iterator(setup);
+ while (scr-- > 0)
+ xcb_screen_next(&iter);
+
+ m_pXcbScreen = iter.data;
+ m_WsiConnection.pConnection = pConnection;
+ m_WsiConnection.root = m_pXcbScreen->root;
+#endif
+ return 0;
+}
+
+xglDisplay::xglDisplay()
+ : m_initedXGL(false),
+ m_windowWidth(0),
+ m_windowHeight(0)
+{
+#if defined(WIN32)
+ m_windowHandle = NULL;
+#elif defined(PLATFORM_LINUX)
+ m_WsiConnection.pConnection = NULL;
+ m_WsiConnection.root = 0;
+ m_WsiConnection.provider = 0;
+ m_pXcbScreen = NULL;
+ m_XcbWindow = 0;
+#endif
+}
+
+xglDisplay::~xglDisplay()
+{
+#ifdef PLATFORM_LINUX
+ xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);
+ xcb_disconnect(m_WsiConnection.pConnection);
+#endif
+}
+
+#if defined(WIN32)
+LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)
+{
+ switch(msg)
+ {
+ case WM_CLOSE:
+ DestroyWindow( window);
+ // fall-thru
+ case WM_DESTROY:
+ PostQuitMessage(0) ;
+ return 0L ;
+ default:
+ return DefWindowProc( window, msg, wp, lp ) ;
+ }
+}
+#endif
+
+int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)
+{
+#if defined(WIN32)
+ m_windowHandle = hWindow;
+#endif
+ m_windowWidth = width;
+ m_windowHeight = height;
+ return 0;
+}
+
+int xglDisplay::create_window(const unsigned int width, const unsigned int height)
+{
+#if defined(WIN32)
+ // Register Window class
+ WNDCLASSEX wcex = {};
+ wcex.cbSize = sizeof( WNDCLASSEX);
+ wcex.style = CS_HREDRAW | CS_VREDRAW;
+ wcex.lpfnWndProc = WindowProcXgl;
+ wcex.cbClsExtra = 0;
+ wcex.cbWndExtra = 0;
+ wcex.hInstance = GetModuleHandle(0);
+ wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));
+ wcex.hCursor = LoadCursor( NULL, IDC_ARROW);
+ wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);
+ wcex.lpszMenuName = NULL;
+ wcex.lpszClassName = APP_NAME;
+ wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));
+ if( !RegisterClassEx( &wcex))
+ {
+ glv_LogError("Failed to register windows class\n");
+ return -1;
+ }
+
+ // create the window
+ m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,
+ width, height, NULL, NULL, wcex.hInstance, NULL);
+
+ if (m_windowHandle)
+ {
+ ShowWindow( m_windowHandle, SW_SHOWDEFAULT);
+ m_windowWidth = width;
+ m_windowHeight = height;
+ } else {
+ glv_LogError("Failed to create window\n");
+ return -1;
+ }
+
+ return 0;
+#elif defined(PLATFORM_LINUX)
+
+ uint32_t value_mask, value_list[32];
+ m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);
+
+ value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+ value_list[0] = m_pXcbScreen->black_pixel;
+ value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |
+ XCB_EVENT_MASK_EXPOSURE;
+
+ xcb_create_window(m_WsiConnection.pConnection,
+ XCB_COPY_FROM_PARENT,
+ m_XcbWindow, m_WsiConnection.root,
+ 0, 0, width, height, 0,
+ XCB_WINDOW_CLASS_INPUT_OUTPUT,
+ m_pXcbScreen->root_visual,
+ value_mask, value_list);
+
+ xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);
+ xcb_flush(m_WsiConnection.pConnection);
+ return 0;
+#endif
+}
+
+void xglDisplay::resize_window(const unsigned int width, const unsigned int height)
+{
+#if defined(WIN32)
+ if (width != m_windowWidth || height != m_windowHeight)
+ {
+ SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);
+ m_windowWidth = width;
+ m_windowHeight = height;
+ }
+#elif defined(PLATFORM_LINUX)
+ if (width != m_windowWidth || height != m_windowHeight)
+ {
+ uint32_t values[2];
+ values[0] = width;
+ values[1] = height;
+ xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);
+ m_windowWidth = width;
+ m_windowHeight = height;
+ }
+#endif
+}
+
+void xglDisplay::process_event()
+{
+}
+
+xglReplay::xglReplay(unsigned int debugLevel)
+{
+ m_display = new xglDisplay();
+ m_debugLevel = debugLevel;
+}
+
+xglReplay::~xglReplay()
+{
+ delete m_display;
+ glv_platform_close_library(m_xglFuncs.m_libHandle);
+}
+
+int xglReplay::init(glv_replay::Display & disp)
+{
+ int err;
+#if defined _WIN64
+ HMODULE handle = LoadLibrary("xgl64.dll" );
+#elif defined _WIN32
+ HMODULE handle = LoadLibrary("xgl32.dll" );
+#elif defined PLATFORM_LINUX
+ void * handle = dlopen("libXGL.so", RTLD_LAZY);
+#endif
+
+ if (handle == NULL) {
+ glv_LogError("Failed to open xgl library.\n");
+ return -1;
+ }
+
+ m_xglFuncs.init_funcs(handle);
+
+ disp.set_implementation(m_display);
+
+ if ((err = m_display->init(disp.get_gpu())) != 0) {
+ glv_LogError("Failed to init XGL display.\n");
+ return err;
+ }
+
+ if (disp.get_window_handle() == 0)
+ {
+ if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {
+ glv_LogError("Failed to create Window\n");
+ return err;
+ }
+ }
+ else
+ {
+ if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)
+ {
+ glv_LogError("Failed to set Window\n");
+ return err;
+ }
+ }
+
+ return 0;
+}
+
+void xglReplay::copy_mem_remap_range_struct(XGL_VIRTUAL_MEMORY_REMAP_RANGE *outRange, const XGL_VIRTUAL_MEMORY_REMAP_RANGE *inRange)
+{
+ outRange->pageCount = inRange->pageCount;
+ outRange->realStartPage = inRange->realStartPage;
+ outRange->realMem = remap(inRange->realMem);
+ outRange->virtualStartPage = inRange->virtualStartPage;
+ outRange->virtualMem = remap(inRange->virtualMem);
+}
+
+glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)
+{
+ glv_replay::GLV_REPLAY_RESULT res = resIn;
+ if (resCall != resTrace) {
+ glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\n", entrypointName,
+ string_XGL_RESULT(resTrace), string_XGL_RESULT(resCall));
+ res = glv_replay::GLV_REPLAY_BAD_RETURN;
+ }
+
+#if 0
+ if (resCall != XGL_SUCCESS) {
+ glv_LogWarn("API call (%s) returned failed result %s\n", entrypointName, string_XGL_RESULT(resCall));
+ }
+#endif
+ return res;
+}
+
+void xglFuncs::init_funcs(void * handle)
+{
+ m_libHandle = handle;
+ real_xglInitAndEnumerateGpus = (type_xglInitAndEnumerateGpus)(glv_platform_get_library_entrypoint(handle, "xglInitAndEnumerateGpus"));
+ real_xglGetGpuInfo = (type_xglGetGpuInfo)(glv_platform_get_library_entrypoint(handle, "xglGetGpuInfo"));
+ real_xglCreateDevice = (type_xglCreateDevice)(glv_platform_get_library_entrypoint(handle, "xglCreateDevice"));
+ real_xglDestroyDevice = (type_xglDestroyDevice)(glv_platform_get_library_entrypoint(handle, "xglDestroyDevice"));
+ real_xglGetExtensionSupport = (type_xglGetExtensionSupport)(glv_platform_get_library_entrypoint(handle, "xglGetExtensionSupport"));
+ real_xglGetDeviceQueue = (type_xglGetDeviceQueue)(glv_platform_get_library_entrypoint(handle, "xglGetDeviceQueue"));
+ real_xglQueueSubmit = (type_xglQueueSubmit)(glv_platform_get_library_entrypoint(handle, "xglQueueSubmit"));
+ real_xglQueueSetGlobalMemReferences = (type_xglQueueSetGlobalMemReferences)(glv_platform_get_library_entrypoint(handle, "xglQueueSetGlobalMemReferences"));
+ real_xglQueueWaitIdle = (type_xglQueueWaitIdle)(glv_platform_get_library_entrypoint(handle, "xglQueueWaitIdle"));
+ real_xglDeviceWaitIdle = (type_xglDeviceWaitIdle)(glv_platform_get_library_entrypoint(handle, "xglDeviceWaitIdle"));
+ real_xglGetMemoryHeapCount = (type_xglGetMemoryHeapCount)(glv_platform_get_library_entrypoint(handle, "xglGetMemoryHeapCount"));
+ real_xglGetMemoryHeapInfo = (type_xglGetMemoryHeapInfo)(glv_platform_get_library_entrypoint(handle, "xglGetMemoryHeapInfo"));
+ real_xglAllocMemory = (type_xglAllocMemory)(glv_platform_get_library_entrypoint(handle, "xglAllocMemory"));
+ real_xglFreeMemory = (type_xglFreeMemory)(glv_platform_get_library_entrypoint(handle, "xglFreeMemory"));
+ real_xglSetMemoryPriority = (type_xglSetMemoryPriority)(glv_platform_get_library_entrypoint(handle, "xglSetMemoryPriority"));
+ real_xglMapMemory = (type_xglMapMemory)(glv_platform_get_library_entrypoint(handle, "xglMapMemory"));
+ real_xglUnmapMemory = (type_xglUnmapMemory)(glv_platform_get_library_entrypoint(handle, "xglUnmapMemory"));
+ real_xglPinSystemMemory = (type_xglPinSystemMemory)(glv_platform_get_library_entrypoint(handle, "xglPinSystemMemory"));
+ real_xglRemapVirtualMemoryPages = (type_xglRemapVirtualMemoryPages)(glv_platform_get_library_entrypoint(handle, "xglRemapVirtualMemoryPages"));
+ real_xglGetMultiGpuCompatibility = (type_xglGetMultiGpuCompatibility)(glv_platform_get_library_entrypoint(handle, "xglGetMultiGpuCompatibility"));
+ real_xglOpenSharedMemory = (type_xglOpenSharedMemory)(glv_platform_get_library_entrypoint(handle, "xglOpenSharedMemory"));
+ real_xglOpenSharedQueueSemaphore = (type_xglOpenSharedQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglOpenSharedQueueSemaphore"));
+ real_xglOpenPeerMemory = (type_xglOpenPeerMemory)(glv_platform_get_library_entrypoint(handle, "xglOpenPeerMemory"));
+ real_xglOpenPeerImage = (type_xglOpenPeerImage)(glv_platform_get_library_entrypoint(handle, "xglOpenPeerImage"));
+ real_xglDestroyObject = (type_xglDestroyObject)(glv_platform_get_library_entrypoint(handle, "xglDestroyObject"));
+ real_xglGetObjectInfo = (type_xglGetObjectInfo)(glv_platform_get_library_entrypoint(handle, "xglGetObjectInfo"));
+ real_xglBindObjectMemory = (type_xglBindObjectMemory)(glv_platform_get_library_entrypoint(handle, "xglBindObjectMemory"));
+ real_xglCreateFence = (type_xglCreateFence)(glv_platform_get_library_entrypoint(handle, "xglCreateFence"));
+ real_xglGetFenceStatus = (type_xglGetFenceStatus)(glv_platform_get_library_entrypoint(handle, "xglGetFenceStatus"));
+ real_xglWaitForFences = (type_xglWaitForFences)(glv_platform_get_library_entrypoint(handle, "xglWaitForFences"));
+ real_xglCreateQueueSemaphore = (type_xglCreateQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglCreateQueueSemaphore"));
+ real_xglSignalQueueSemaphore = (type_xglSignalQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglSignalQueueSemaphore"));
+ real_xglWaitQueueSemaphore = (type_xglWaitQueueSemaphore)(glv_platform_get_library_entrypoint(handle, "xglWaitQueueSemaphore"));
+ real_xglCreateEvent = (type_xglCreateEvent)(glv_platform_get_library_entrypoint(handle, "xglCreateEvent"));
+ real_xglGetEventStatus = (type_xglGetEventStatus)(glv_platform_get_library_entrypoint(handle, "xglGetEventStatus"));
+ real_xglSetEvent = (type_xglSetEvent)(glv_platform_get_library_entrypoint(handle, "xglSetEvent"));
+ real_xglResetEvent = (type_xglResetEvent)(glv_platform_get_library_entrypoint(handle, "xglResetEvent"));
+ real_xglCreateQueryPool = (type_xglCreateQueryPool)(glv_platform_get_library_entrypoint(handle, "xglCreateQueryPool"));
+ real_xglGetQueryPoolResults = (type_xglGetQueryPoolResults)(glv_platform_get_library_entrypoint(handle, "xglGetQueryPoolResults"));
+ real_xglGetFormatInfo = (type_xglGetFormatInfo)(glv_platform_get_library_entrypoint(handle, "xglGetFormatInfo"));
+ real_xglCreateImage = (type_xglCreateImage)(glv_platform_get_library_entrypoint(handle, "xglCreateImage"));
+ real_xglGetImageSubresourceInfo = (type_xglGetImageSubresourceInfo)(glv_platform_get_library_entrypoint(handle, "xglGetImageSubresourceInfo"));
+ real_xglCreateImageView = (type_xglCreateImageView)(glv_platform_get_library_entrypoint(handle, "xglCreateImageView"));
+ real_xglCreateColorAttachmentView = (type_xglCreateColorAttachmentView)(glv_platform_get_library_entrypoint(handle, "xglCreateColorAttachmentView"));
+ real_xglCreateDepthStencilView = (type_xglCreateDepthStencilView)(glv_platform_get_library_entrypoint(handle, "xglCreateDepthStencilView"));
+ real_xglCreateShader = (type_xglCreateShader)(glv_platform_get_library_entrypoint(handle, "xglCreateShader"));
+ real_xglCreateGraphicsPipeline = (type_xglCreateGraphicsPipeline)(glv_platform_get_library_entrypoint(handle, "xglCreateGraphicsPipeline"));
+ real_xglCreateComputePipeline = (type_xglCreateComputePipeline)(glv_platform_get_library_entrypoint(handle, "xglCreateComputePipeline"));
+ real_xglStorePipeline = (type_xglStorePipeline)(glv_platform_get_library_entrypoint(handle, "xglStorePipeline"));
+ real_xglCreatePipelineDelta = (type_xglCreatePipelineDelta)(glv_platform_get_library_entrypoint(handle, "xglCreatePipelineDelta"));
+ real_xglLoadPipeline = (type_xglLoadPipeline)(glv_platform_get_library_entrypoint(handle, "xglLoadPipeline"));
+ real_xglCreateSampler = (type_xglCreateSampler)(glv_platform_get_library_entrypoint(handle, "xglCreateSampler"));
+ real_xglCreateDescriptorSet = (type_xglCreateDescriptorSet)(glv_platform_get_library_entrypoint(handle, "xglCreateDescriptorSet"));
+ real_xglBeginDescriptorSetUpdate = (type_xglBeginDescriptorSetUpdate)(glv_platform_get_library_entrypoint(handle, "xglBeginDescriptorSetUpdate"));
+ real_xglEndDescriptorSetUpdate = (type_xglEndDescriptorSetUpdate)(glv_platform_get_library_entrypoint(handle, "xglEndDescriptorSetUpdate"));
+ real_xglAttachSamplerDescriptors = (type_xglAttachSamplerDescriptors)(glv_platform_get_library_entrypoint(handle, "xglAttachSamplerDescriptors"));
+ real_xglAttachImageViewDescriptors = (type_xglAttachImageViewDescriptors)(glv_platform_get_library_entrypoint(handle, "xglAttachImageViewDescriptors"));
+ real_xglAttachMemoryViewDescriptors = (type_xglAttachMemoryViewDescriptors)(glv_platform_get_library_entrypoint(handle, "xglAttachMemoryViewDescriptors"));
+ real_xglAttachNestedDescriptors = (type_xglAttachNestedDescriptors)(glv_platform_get_library_entrypoint(handle, "xglAttachNestedDescriptors"));
+ real_xglClearDescriptorSetSlots = (type_xglClearDescriptorSetSlots)(glv_platform_get_library_entrypoint(handle, "xglClearDescriptorSetSlots"));
+ real_xglCreateViewportState = (type_xglCreateViewportState)(glv_platform_get_library_entrypoint(handle, "xglCreateViewportState"));
+ real_xglCreateRasterState = (type_xglCreateRasterState)(glv_platform_get_library_entrypoint(handle, "xglCreateRasterState"));
+ real_xglCreateMsaaState = (type_xglCreateMsaaState)(glv_platform_get_library_entrypoint(handle, "xglCreateMsaaState"));
+ real_xglCreateColorBlendState = (type_xglCreateColorBlendState)(glv_platform_get_library_entrypoint(handle, "xglCreateColorBlendState"));
+ real_xglCreateDepthStencilState = (type_xglCreateDepthStencilState)(glv_platform_get_library_entrypoint(handle, "xglCreateDepthStencilState"));
+ real_xglCreateCommandBuffer = (type_xglCreateCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglCreateCommandBuffer"));
+ real_xglBeginCommandBuffer = (type_xglBeginCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglBeginCommandBuffer"));
+ real_xglEndCommandBuffer = (type_xglEndCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglEndCommandBuffer"));
+ real_xglResetCommandBuffer = (type_xglResetCommandBuffer)(glv_platform_get_library_entrypoint(handle, "xglResetCommandBuffer"));
+ real_xglCmdBindPipeline = (type_xglCmdBindPipeline)(glv_platform_get_library_entrypoint(handle, "xglCmdBindPipeline"));
+ real_xglCmdBindPipelineDelta = (type_xglCmdBindPipelineDelta)(glv_platform_get_library_entrypoint(handle, "xglCmdBindPipelineDelta"));
+ real_xglCmdBindStateObject = (type_xglCmdBindStateObject)(glv_platform_get_library_entrypoint(handle, "xglCmdBindStateObject"));
+ real_xglCmdBindDescriptorSet = (type_xglCmdBindDescriptorSet)(glv_platform_get_library_entrypoint(handle, "xglCmdBindDescriptorSet"));
+ real_xglCmdBindDynamicMemoryView = (type_xglCmdBindDynamicMemoryView)(glv_platform_get_library_entrypoint(handle, "xglCmdBindDynamicMemoryView"));
+ real_xglCmdBindIndexData = (type_xglCmdBindIndexData)(glv_platform_get_library_entrypoint(handle, "xglCmdBindIndexData"));
+ real_xglCmdBindAttachments = (type_xglCmdBindAttachments)(glv_platform_get_library_entrypoint(handle, "xglCmdBindAttachments"));
+ real_xglCmdPrepareMemoryRegions = (type_xglCmdPrepareMemoryRegions)(glv_platform_get_library_entrypoint(handle, "xglCmdPrepareMemoryRegions"));
+ real_xglCmdPrepareImages = (type_xglCmdPrepareImages)(glv_platform_get_library_entrypoint(handle, "xglCmdPrepareImages"));
+ real_xglCmdDraw = (type_xglCmdDraw)(glv_platform_get_library_entrypoint(handle, "xglCmdDraw"));
+ real_xglCmdDrawIndexed = (type_xglCmdDrawIndexed)(glv_platform_get_library_entrypoint(handle, "xglCmdDrawIndexed"));
+ real_xglCmdDrawIndirect = (type_xglCmdDrawIndirect)(glv_platform_get_library_entrypoint(handle, "xglCmdDrawIndirect"));
+ real_xglCmdDrawIndexedIndirect = (type_xglCmdDrawIndexedIndirect)(glv_platform_get_library_entrypoint(handle, "xglCmdDrawIndexedIndirect"));
+ real_xglCmdDispatch = (type_xglCmdDispatch)(glv_platform_get_library_entrypoint(handle, "xglCmdDispatch"));
+ real_xglCmdDispatchIndirect = (type_xglCmdDispatchIndirect)(glv_platform_get_library_entrypoint(handle, "xglCmdDispatchIndirect"));
+ real_xglCmdCopyMemory = (type_xglCmdCopyMemory)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyMemory"));
+ real_xglCmdCopyImage = (type_xglCmdCopyImage)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyImage"));
+ real_xglCmdCopyMemoryToImage = (type_xglCmdCopyMemoryToImage)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyMemoryToImage"));
+ real_xglCmdCopyImageToMemory = (type_xglCmdCopyImageToMemory)(glv_platform_get_library_entrypoint(handle, "xglCmdCopyImageToMemory"));
+ real_xglCmdCloneImageData = (type_xglCmdCloneImageData)(glv_platform_get_library_entrypoint(handle, "xglCmdCloneImageData"));
+ real_xglCmdUpdateMemory = (type_xglCmdUpdateMemory)(glv_platform_get_library_entrypoint(handle, "xglCmdUpdateMemory"));
+ real_xglCmdFillMemory = (type_xglCmdFillMemory)(glv_platform_get_library_entrypoint(handle, "xglCmdFillMemory"));
+ real_xglCmdClearColorImage = (type_xglCmdClearColorImage)(glv_platform_get_library_entrypoint(handle, "xglCmdClearColorImage"));
+ real_xglCmdClearColorImageRaw = (type_xglCmdClearColorImageRaw)(glv_platform_get_library_entrypoint(handle, "xglCmdClearColorImageRaw"));
+ real_xglCmdClearDepthStencil = (type_xglCmdClearDepthStencil)(glv_platform_get_library_entrypoint(handle, "xglCmdClearDepthStencil"));
+ real_xglCmdResolveImage = (type_xglCmdResolveImage)(glv_platform_get_library_entrypoint(handle, "xglCmdResolveImage"));
+ real_xglCmdSetEvent = (type_xglCmdSetEvent)(glv_platform_get_library_entrypoint(handle, "xglCmdSetEvent"));
+ real_xglCmdResetEvent = (type_xglCmdResetEvent)(glv_platform_get_library_entrypoint(handle, "xglCmdResetEvent"));
+ real_xglCmdMemoryAtomic = (type_xglCmdMemoryAtomic)(glv_platform_get_library_entrypoint(handle, "xglCmdMemoryAtomic"));
+ real_xglCmdBeginQuery = (type_xglCmdBeginQuery)(glv_platform_get_library_entrypoint(handle, "xglCmdBeginQuery"));
+ real_xglCmdEndQuery = (type_xglCmdEndQuery)(glv_platform_get_library_entrypoint(handle, "xglCmdEndQuery"));
+ real_xglCmdResetQueryPool = (type_xglCmdResetQueryPool)(glv_platform_get_library_entrypoint(handle, "xglCmdResetQueryPool"));
+ real_xglCmdWriteTimestamp = (type_xglCmdWriteTimestamp)(glv_platform_get_library_entrypoint(handle, "xglCmdWriteTimestamp"));
+ real_xglCmdInitAtomicCounters = (type_xglCmdInitAtomicCounters)(glv_platform_get_library_entrypoint(handle, "xglCmdInitAtomicCounters"));
+ real_xglCmdLoadAtomicCounters = (type_xglCmdLoadAtomicCounters)(glv_platform_get_library_entrypoint(handle, "xglCmdLoadAtomicCounters"));
+ real_xglCmdSaveAtomicCounters = (type_xglCmdSaveAtomicCounters)(glv_platform_get_library_entrypoint(handle, "xglCmdSaveAtomicCounters"));
+
+ // debug entrypoints
+ real_xglDbgSetValidationLevel = (type_xglDbgSetValidationLevel)(glv_platform_get_library_entrypoint(handle, "xglDbgSetValidationLevel"));
+ real_xglDbgRegisterMsgCallback = (type_xglDbgRegisterMsgCallback)(glv_platform_get_library_entrypoint(handle, "xglDbgRegisterMsgCallback"));
+ real_xglDbgUnregisterMsgCallback = (type_xglDbgUnregisterMsgCallback)(glv_platform_get_library_entrypoint(handle, "xglDbgUnregisterMsgCallback"));
+ real_xglDbgSetMessageFilter = (type_xglDbgSetMessageFilter)(glv_platform_get_library_entrypoint(handle, "xglDbgSetMessageFilter"));
+ real_xglDbgSetObjectTag = (type_xglDbgSetObjectTag)(glv_platform_get_library_entrypoint(handle, "xglDbgSetObjectTag"));
+ real_xglDbgSetGlobalOption = (type_xglDbgSetGlobalOption)(glv_platform_get_library_entrypoint(handle, "xglDbgSetGlobalOption"));
+ real_xglDbgSetDeviceOption = (type_xglDbgSetDeviceOption)(glv_platform_get_library_entrypoint(handle, "xglDbgSetDeviceOption"));
+ real_xglCmdDbgMarkerBegin = (type_xglCmdDbgMarkerBegin)(glv_platform_get_library_entrypoint(handle, "xglCmdDbgMarkerBegin"));
+ real_xglCmdDbgMarkerEnd = (type_xglCmdDbgMarkerEnd)(glv_platform_get_library_entrypoint(handle, "xglCmdDbgMarkerEnd"));
+
+ // WsiX11Ext entrypoints
+ real_xglWsiX11AssociateConnection = (type_xglWsiX11AssociateConnection)(glv_platform_get_library_entrypoint(handle, "xglWsiX11AssociateConnection"));
+ real_xglWsiX11GetMSC = (type_xglWsiX11GetMSC)(glv_platform_get_library_entrypoint(handle, "xglWsiX11GetMSC"));
+ real_xglWsiX11CreatePresentableImage = (type_xglWsiX11CreatePresentableImage)(glv_platform_get_library_entrypoint(handle, "xglWsiX11CreatePresentableImage"));
+ real_xglWsiX11QueuePresent = (type_xglWsiX11QueuePresent)(glv_platform_get_library_entrypoint(handle, "xglWsiX11QueuePresent"));
+}
+
+#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);
+
+glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)
+{
+ glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;
+ XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;
+
+ switch (packet->packet_id)
+ {
+ case GLV_TPI_XGL_xglInitAndEnumerateGpus:
+ {
+ struct_xglInitAndEnumerateGpus* pPacket;
+ pPacket = interpret_body_as_xglInitAndEnumerateGpus(packet);
+
+ // skip this call if XGL already inited
+ if (!m_display->m_initedXGL)
+ {
+ XGL_UINT gpuCount;
+ XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];
+ XGL_UINT maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;
+ replayResult = m_xglFuncs.real_xglInitAndEnumerateGpus(pPacket->pAppInfo, pPacket->pAllocCb, maxGpus, &gpuCount, &gpus[0]);
+ CHECK_RETURN_VALUE(xglInitAndEnumerateGpus);
+ //TODO handle different number of gpus in trace versus replay
+ if (gpuCount != *(pPacket->pGpuCount))
+ {
+ glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\n", gpuCount, *(pPacket->pGpuCount));
+ }
+ else if (gpuCount == 0)
+ {
+ glv_LogError("xglInitAndEnumerateGpus number of gpus is zero\n");
+ }
+ else
+ {
+ glv_LogInfo("Enumerated %d GPUs in the system\n", gpuCount);
+ }
+ clear_all_map_handles();
+ // TODO handle enumeration results in a different order from trace to replay
+ for (XGL_UINT i = 0; i < gpuCount; i++)
+ {
+ if (pPacket->pGpus)
+ add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));
+ }
+ }
+ //TODO check gpu handles for consistency with trace gpus using xglGetGPUInfo
+ break;
+ }
+ case GLV_TPI_XGL_xglGetGpuInfo:
+ {
+ struct_xglGetGpuInfo * pPacket;
+ pPacket = interpret_body_as_xglGetGpuInfo(packet);
+
+ // skip this call if xgl inited
+ if (!m_display->m_initedXGL)
+ {
+ switch (pPacket->infoType) {
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ {
+ XGL_PHYSICAL_GPU_PROPERTIES gpuProps;
+ XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,
+ (pPacket->pData == NULL) ? NULL : &gpuProps);
+ if (pPacket->pData != NULL)
+ {
+ glv_LogInfo("Replay Gpu Properties\n");
+ glv_LogInfo("Vendor ID %x, Device ID %x, name %s\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);
+ glv_LogInfo("API version %u, Driver version %u, gpu Type %u\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);
+ }
+ break;
+ }
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ {
+ XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;
+ XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,
+ (pPacket->pData == NULL) ? NULL : &gpuPerfs);
+ if (pPacket->pData != NULL)
+ {
+ glv_LogInfo("Replay Gpu Performance\n");
+ glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);
+ glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);
+ }
+ break;
+ }
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ {
+ XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;
+ XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
+ XGL_SIZE numQueues = 1;
+ assert(pPacket->pDataSize);
+ if ((*(pPacket->pDataSize) % dataSize) != 0)
+ glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\n");
+ else
+ numQueues = *(pPacket->pDataSize) / dataSize;
+ dataSize = numQueues * dataSize;
+ pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));
+ pGpuQueue = pQ;
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,
+ (pPacket->pData == NULL) ? NULL : pGpuQueue);
+ if (pPacket->pData != NULL)
+ {
+ for (unsigned int i = 0; i < numQueues; i++)
+ {
+ glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\n", i, pGpuQueue->queueFlags);
+ glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);
+ pGpuQueue++;
+ }
+ }
+ glv_free(pQ);
+ break;
+ }
+ default:
+ {
+ XGL_SIZE size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData == NULL)
+ {
+ glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ break;
+ }
+ };
+ CHECK_RETURN_VALUE(xglGetGpuInfo);
+ }
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDevice:
+ {
+ struct_xglCreateDevice * pPacket;
+ pPacket = interpret_body_as_xglCreateDevice(packet);
+ if (!m_display->m_initedXGL)
+ {
+ XGL_DEVICE device;
+ XGL_DEVICE_CREATE_INFO cInfo;
+
+ if (m_debugLevel > 0)
+ {
+ memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));
+ cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;
+ cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((m_debugLevel <= 4) ? XGL_VALIDATION_LEVEL_0 + m_debugLevel : XGL_VALIDATION_LEVEL_0);
+ pPacket->pCreateInfo = &cInfo;
+ }
+ replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);
+ CHECK_RETURN_VALUE(xglCreateDevice);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pDevice, &device);
+ }
+ }
+ break;
+ }
+ case GLV_TPI_XGL_xglDestroyDevice:
+ {
+ struct_xglDestroyDevice * pPacket;
+ pPacket = interpret_body_as_xglDestroyDevice(packet);
+ replayResult = m_xglFuncs.real_xglDestroyDevice(remap(pPacket->device));
+ if (replayResult == XGL_SUCCESS)
+ {
+ rm_from_map(pPacket->device);
+ m_display->m_initedXGL = false;
+ }
+ CHECK_RETURN_VALUE(xglDestroyDevice);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetExtensionSupport:
+ {
+ struct_xglGetExtensionSupport * pPacket;
+ pPacket = interpret_body_as_xglGetExtensionSupport(packet);
+ if (!m_display->m_initedXGL) {
+ replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);
+ CHECK_RETURN_VALUE(xglGetExtensionSupport);
+ if (replayResult == XGL_SUCCESS) {
+ for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)
+ {
+ if (!strncmp((const char *)g_extensions[ext], (const char *)pPacket->pExtName, strlen(g_extensions[ext]))) {
+ bool extInList = false;
+ for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {
+ if (!strncmp((const char *)m_display->m_extensions[j], (const char *)g_extensions[ext], strlen(g_extensions[ext])))
+ extInList = true;
+ break;
+ }
+ if (!extInList)
+ m_display->m_extensions.push_back((XGL_CHAR *) g_extensions[ext]);
+ break;
+ }
+ }
+ }
+ }
+ break;
+ }
+ case GLV_TPI_XGL_xglGetDeviceQueue:
+ {
+ struct_xglGetDeviceQueue *pPacket;
+ pPacket = interpret_body_as_xglGetDeviceQueue(packet);
+ XGL_QUEUE q;
+ replayResult = m_xglFuncs.real_xglGetDeviceQueue(remap(pPacket->device), pPacket->queueType, pPacket->queueIndex, &q);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pQueue, &q);
+ }
+ CHECK_RETURN_VALUE(xglGetDeviceQueue);
+ break;
+ }
+ case GLV_TPI_XGL_xglQueueSubmit:
+ {
+ struct_xglQueueSubmit *pPacket;
+ pPacket = interpret_body_as_xglQueueSubmit(packet);
+ XGL_CMD_BUFFER *remappedBuffers = NULL;
+ if (pPacket->pCmdBuffers != NULL)
+ {
+ remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);
+ for (XGL_UINT i = 0; i < pPacket->cmdBufferCount; i++)
+ {
+ *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));
+ }
+ }
+
+ XGL_MEMORY_REF* memRefs = NULL;
+ if (pPacket->pMemRefs != NULL)
+ {
+ memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);
+ memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);
+ for (XGL_UINT i = 0; i < pPacket->memRefCount; i++)
+ {
+ memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);
+ }
+ }
+
+ replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,
+ memRefs, remap(pPacket->fence));
+ GLV_DELETE(remappedBuffers);
+ GLV_DELETE(memRefs);
+ CHECK_RETURN_VALUE(xglQueueSubmit);
+ break;
+ }
+ case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
+ {
+ struct_xglQueueSetGlobalMemReferences *pPacket;
+ pPacket = interpret_body_as_xglQueueSetGlobalMemReferences(packet);
+ replayResult = m_xglFuncs.real_xglQueueSetGlobalMemReferences(remap(pPacket->queue), pPacket->memRefCount, pPacket->pMemRefs);
+ CHECK_RETURN_VALUE(xglQueueSetGlobalMemReferences);
+ break;
+ }
+ case GLV_TPI_XGL_xglQueueWaitIdle:
+ {
+ struct_xglQueueWaitIdle *pPacket;
+ pPacket = interpret_body_as_xglQueueWaitIdle(packet);
+ replayResult = m_xglFuncs.real_xglQueueWaitIdle(remap(pPacket->queue));
+ CHECK_RETURN_VALUE(xglQueueWaitIdle);
+ break;
+ }
+ case GLV_TPI_XGL_xglDeviceWaitIdle:
+ {
+ struct_xglDeviceWaitIdle *pPacket;
+ pPacket = interpret_body_as_xglDeviceWaitIdle(packet);
+ replayResult = m_xglFuncs.real_xglDeviceWaitIdle(remap(pPacket->device));
+ CHECK_RETURN_VALUE(xglDeviceWaitIdle);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetMemoryHeapCount:
+ {
+ struct_xglGetMemoryHeapCount *pPacket;
+ XGL_UINT count;
+ pPacket = interpret_body_as_xglGetMemoryHeapCount(packet);
+ replayResult = m_xglFuncs.real_xglGetMemoryHeapCount(remap(pPacket->device), &count);
+ if (count < 1 || count >= XGL_MAX_MEMORY_HEAPS)
+ glv_LogError("xglGetMemoryHeapCount returned bad value count = %u\n", count);
+ CHECK_RETURN_VALUE(xglGetMemoryHeapCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetMemoryHeapInfo:
+ {
+ // TODO handle case where traced heap count, ids and properties do not match replay heaps
+ struct_xglGetMemoryHeapInfo *pPacket;
+ XGL_SIZE dataSize = sizeof(XGL_MEMORY_HEAP_PROPERTIES);
+ pPacket = interpret_body_as_xglGetMemoryHeapInfo(packet);
+ // TODO check returned properties match queried properties if this makes sense
+ if (pPacket->heapId >= XGL_MAX_MEMORY_HEAPS)
+ {
+ glv_LogError("xglGetMemoryHeapInfo bad heapid (%d) skipping packet\n");
+ break;
+ }
+ replayResult = m_xglFuncs.real_xglGetMemoryHeapInfo(remap(pPacket->device), pPacket->heapId, pPacket->infoType, &dataSize,
+ static_cast <XGL_VOID *> (&(m_heapProps[pPacket->heapId])));
+ if (dataSize != sizeof(XGL_MEMORY_HEAP_PROPERTIES))
+ glv_LogError("xglGetMemoryHeapInfo returned bad size = %u\n", dataSize);
+ CHECK_RETURN_VALUE(xglGetMemoryHeapCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglAllocMemory:
+ {
+ struct_xglAllocMemory *pPacket;
+ XGL_GPU_MEMORY handle;
+ pPacket = interpret_body_as_xglAllocMemory(packet);
+ replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &handle);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pMem, &handle);
+ add_entry_to_mapData(handle, pPacket->pAllocInfo->allocationSize);
+ }
+ CHECK_RETURN_VALUE(xglAllocMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglFreeMemory:
+ {
+ struct_xglFreeMemory *pPacket;
+ pPacket = interpret_body_as_xglFreeMemory(packet);
+ XGL_GPU_MEMORY handle = remap(pPacket->mem);
+ replayResult = m_xglFuncs.real_xglFreeMemory(handle);
+ if (replayResult == XGL_SUCCESS)
+ {
+ rm_entry_from_mapData(handle);
+ rm_from_map(pPacket->mem);
+ }
+ CHECK_RETURN_VALUE(xglFreeMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglSetMemoryPriority:
+ {
+ struct_xglSetMemoryPriority *pPacket;
+ pPacket = interpret_body_as_xglSetMemoryPriority(packet);
+ replayResult = m_xglFuncs.real_xglSetMemoryPriority(remap(pPacket->mem), pPacket->priority);
+ CHECK_RETURN_VALUE(xglSetMemoryPriority);
+ break;
+ }
+ case GLV_TPI_XGL_xglMapMemory:
+ {
+ struct_xglMapMemory *pPacket;
+ pPacket = interpret_body_as_xglMapMemory(packet);
+ XGL_GPU_MEMORY handle = remap(pPacket->mem);
+ XGL_VOID* pData;
+ replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);
+ if (replayResult == XGL_SUCCESS)
+ add_mapping_to_mapData(handle, pData);
+ CHECK_RETURN_VALUE(xglMapMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglUnmapMemory:
+ {
+ struct_xglUnmapMemory *pPacket;
+ pPacket = interpret_body_as_xglUnmapMemory(packet);
+ XGL_GPU_MEMORY handle = remap(pPacket->mem);
+ rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer
+ replayResult = m_xglFuncs.real_xglUnmapMemory(handle);
+ CHECK_RETURN_VALUE(xglUnmapMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglPinSystemMemory:
+ {
+ struct_xglPinSystemMemory *pPacket;
+ pPacket = interpret_body_as_xglPinSystemMemory(packet);
+ XGL_GPU_MEMORY memHandle;
+ replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &memHandle);
+ if (replayResult == XGL_SUCCESS)
+ add_to_map(pPacket->pMem, &memHandle);
+ CHECK_RETURN_VALUE(xglPinSystemMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglRemapVirtualMemoryPages:
+ {
+ struct_xglRemapVirtualMemoryPages *pPacket;
+ pPacket = interpret_body_as_xglRemapVirtualMemoryPages(packet);
+ XGL_VIRTUAL_MEMORY_REMAP_RANGE *pRemappedRanges = GLV_NEW_ARRAY( XGL_VIRTUAL_MEMORY_REMAP_RANGE, pPacket->rangeCount);
+ for (XGL_UINT i = 0; i < pPacket->rangeCount; i++)
+ {
+ copy_mem_remap_range_struct(pRemappedRanges + i, (pPacket->pRanges + i));
+ }
+ XGL_QUEUE_SEMAPHORE *pRemappedPreSema = GLV_NEW_ARRAY(XGL_QUEUE_SEMAPHORE, pPacket->preWaitSemaphoreCount);
+ for (XGL_UINT i = 0; i < pPacket->preWaitSemaphoreCount; i++)
+ {
+ *(pRemappedPreSema + i) = *(pPacket->pPreWaitSemaphores + i);
+ }
+ XGL_QUEUE_SEMAPHORE *pRemappedPostSema = GLV_NEW_ARRAY(XGL_QUEUE_SEMAPHORE, pPacket->postSignalSemaphoreCount);
+ for (XGL_UINT i = 0; i < pPacket->postSignalSemaphoreCount; i++)
+ {
+ *(pRemappedPostSema + i) = *(pPacket->pPostSignalSemaphores + i);
+ }
+ replayResult = m_xglFuncs.real_xglRemapVirtualMemoryPages(remap(pPacket->device), pPacket->rangeCount, pRemappedRanges, pPacket->preWaitSemaphoreCount,
+ pPacket->pPreWaitSemaphores, pPacket->postSignalSemaphoreCount, pPacket->pPostSignalSemaphores);
+ GLV_DELETE(pRemappedRanges);
+ GLV_DELETE(pRemappedPreSema);
+ GLV_DELETE(pRemappedPostSema);
+ CHECK_RETURN_VALUE(xglRemapVirtualMemoryPages);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
+ {
+ struct_xglGetMultiGpuCompatibility *pPacket;
+ XGL_GPU_COMPATIBILITY_INFO cInfo;
+ XGL_PHYSICAL_GPU handle0, handle1;
+ pPacket = interpret_body_as_xglGetMultiGpuCompatibility(packet);
+ handle0 = remap(pPacket->gpu0);
+ handle1 = remap(pPacket->gpu1);
+ replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);
+ CHECK_RETURN_VALUE(xglGetMultiGpuCompatibility);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenSharedMemory:
+ {
+ struct_xglOpenSharedMemory *pPacket;
+ XGL_DEVICE handle;
+ XGL_GPU_MEMORY mem;
+ pPacket = interpret_body_as_xglOpenSharedMemory(packet);
+ handle = remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenSharedMemory(handle, pPacket->pOpenInfo, &mem);
+ CHECK_RETURN_VALUE(xglOpenSharedMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
+ {
+ struct_xglOpenSharedQueueSemaphore *pPacket;
+ XGL_DEVICE handle;
+ XGL_QUEUE_SEMAPHORE sema;
+ pPacket = interpret_body_as_xglOpenSharedQueueSemaphore(packet);
+ handle = remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenSharedQueueSemaphore(handle, pPacket->pOpenInfo, &sema);
+ CHECK_RETURN_VALUE(xglOpenSharedQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenPeerMemory:
+ {
+ struct_xglOpenPeerMemory *pPacket;
+ XGL_DEVICE handle;
+ XGL_GPU_MEMORY mem;
+ pPacket = interpret_body_as_xglOpenPeerMemory(packet);
+ handle = remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenPeerMemory(handle, pPacket->pOpenInfo, &mem);
+ CHECK_RETURN_VALUE(xglOpenPeerMemory);
+ break;
+ }
+ case GLV_TPI_XGL_xglOpenPeerImage:
+ {
+ struct_xglOpenPeerImage *pPacket;
+ XGL_DEVICE handle;
+ XGL_GPU_MEMORY mem;
+ XGL_IMAGE img;
+ pPacket = interpret_body_as_xglOpenPeerImage(packet);
+ handle = remap(pPacket->device);
+ replayResult = m_xglFuncs.real_xglOpenPeerImage(handle, pPacket->pOpenInfo, &img, &mem);
+ CHECK_RETURN_VALUE(xglOpenPeerImage);
+ break;
+ }
+ case GLV_TPI_XGL_xglDestroyObject:
+ {
+ struct_xglDestroyObject *pPacket;
+ pPacket = interpret_body_as_xglDestroyObject(packet);
+ XGL_OBJECT object = remap(pPacket->object);
+ if (object != XGL_NULL_HANDLE)
+ replayResult = m_xglFuncs.real_xglDestroyObject(object);
+ if (replayResult == XGL_SUCCESS)
+ rm_from_map(pPacket->object);
+ CHECK_RETURN_VALUE(xglDestroyObject);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetObjectInfo:
+ {
+ struct_xglGetObjectInfo *pPacket;
+ pPacket = interpret_body_as_xglGetObjectInfo(packet);
+
+ XGL_SIZE size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ memcpy(pData, pPacket->pData, *pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData == NULL)
+ {
+ glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglGetObjectInfo);
+ break;
+ }
+ case GLV_TPI_XGL_xglBindObjectMemory:
+ {
+ struct_xglBindObjectMemory *pPacket;
+ pPacket = interpret_body_as_xglBindObjectMemory(packet);
+ replayResult = m_xglFuncs.real_xglBindObjectMemory(remap(pPacket->object), remap(pPacket->mem), pPacket->offset);
+ CHECK_RETURN_VALUE(xglBindObjectInfo);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateFence:
+ {
+ struct_xglCreateFence* pPacket = interpret_body_as_xglCreateFence(packet);
+ XGL_FENCE fence;
+ replayResult = m_xglFuncs.real_xglCreateFence(remap(pPacket->device), pPacket->pCreateInfo, &fence);
+ if (replayResult == XGL_SUCCESS)
+ add_to_map(pPacket->pFence, &fence);
+ CHECK_RETURN_VALUE(xglCreateFence);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetFenceStatus:
+ {
+ struct_xglGetFenceStatus* pPacket = interpret_body_as_xglGetFenceStatus(packet);
+ replayResult = m_xglFuncs.real_xglGetFenceStatus(remap(pPacket->fence));
+ CHECK_RETURN_VALUE(xglGetFenceStatus);
+ break;
+ }
+ case GLV_TPI_XGL_xglWaitForFences:
+ {
+ struct_xglWaitForFences* pPacket = interpret_body_as_xglWaitForFences(packet);
+ XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);
+ for (XGL_UINT i = 0; i < pPacket->fenceCount; i++)
+ {
+ *(pFence + i) = remap(*(pPacket->pFences + i));
+ }
+ replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);
+ GLV_DELETE(pFence);
+ CHECK_RETURN_VALUE(xglWaitForFences);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateQueueSemaphore:
+ {
+ struct_xglCreateQueueSemaphore* pPacket = interpret_body_as_xglCreateQueueSemaphore(packet);
+ XGL_QUEUE_SEMAPHORE sema;
+ replayResult = m_xglFuncs.real_xglCreateQueueSemaphore(remap(pPacket->device), pPacket->pCreateInfo, &sema);
+ if (replayResult == XGL_SUCCESS)
+ add_to_map(pPacket->pSemaphore, &sema);
+ CHECK_RETURN_VALUE(xglCreateQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglSignalQueueSemaphore:
+ {
+ struct_xglSignalQueueSemaphore* pPacket = interpret_body_as_xglSignalQueueSemaphore(packet);
+ replayResult = m_xglFuncs.real_xglSignalQueueSemaphore(remap(pPacket->queue), remap(pPacket->semaphore));
+ CHECK_RETURN_VALUE(xglSignalQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglWaitQueueSemaphore:
+ {
+ struct_xglWaitQueueSemaphore* pPacket = interpret_body_as_xglWaitQueueSemaphore(packet);
+ replayResult = m_xglFuncs.real_xglWaitQueueSemaphore(remap(pPacket->queue), remap(pPacket->semaphore));
+ CHECK_RETURN_VALUE(xglWaitQueueSemaphore);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateEvent:
+ {
+ struct_xglCreateEvent* pPacket = interpret_body_as_xglCreateEvent(packet);
+ XGL_EVENT event;
+ replayResult = m_xglFuncs.real_xglCreateEvent(remap(pPacket->device), pPacket->pCreateInfo, &event);
+ if (replayResult == XGL_SUCCESS)
+ add_to_map(pPacket->pEvent, &event);
+ CHECK_RETURN_VALUE(xglCreateEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetEventStatus:
+ {
+ struct_xglGetEventStatus* pPacket = interpret_body_as_xglGetEventStatus(packet);
+ replayResult = m_xglFuncs.real_xglGetEventStatus(remap(pPacket->event));
+ if (replayResult != pPacket->result)
+ {
+ glv_LogWarn("Mismatched return from xglGetEventStatus() traced result %s, replay result %s\n",
+ string_XGL_RESULT(pPacket->result), string_XGL_RESULT(replayResult));
+ returnValue = glv_replay::GLV_REPLAY_BAD_RETURN;
+ }
+
+ if (replayResult != XGL_EVENT_SET && replayResult != XGL_EVENT_RESET)
+ {
+ glv_LogWarn("xglGetEventStatus() returned failed result %s\n", string_XGL_RESULT(replayResult));
+ returnValue = glv_replay::GLV_REPLAY_CALL_ERROR;
+ }
+ break;
+ }
+ case GLV_TPI_XGL_xglSetEvent:
+ {
+ struct_xglSetEvent* pPacket = interpret_body_as_xglSetEvent(packet);
+ replayResult = m_xglFuncs.real_xglSetEvent(remap(pPacket->event));
+ CHECK_RETURN_VALUE(xglSetEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglResetEvent:
+ {
+ struct_xglResetEvent* pPacket = interpret_body_as_xglResetEvent(packet);
+ replayResult = m_xglFuncs.real_xglResetEvent(remap(pPacket->event));
+ CHECK_RETURN_VALUE(xglResetEvent);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateQueryPool:
+ {
+ struct_xglCreateQueryPool* pPacket = interpret_body_as_xglCreateQueryPool(packet);
+ XGL_QUERY_POOL query;
+ replayResult = m_xglFuncs.real_xglCreateQueryPool(remap(pPacket->device), pPacket->pCreateInfo, &query);
+ if (replayResult == XGL_SUCCESS)
+ add_to_map(pPacket->pQueryPool, &query);
+ CHECK_RETURN_VALUE(xglCreateQueryPool);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetQueryPoolResults:
+ {
+ struct_xglGetQueryPoolResults* pPacket = interpret_body_as_xglGetQueryPoolResults(packet);
+ replayResult = m_xglFuncs.real_xglGetQueryPoolResults(remap(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount, pPacket->pDataSize, pPacket->pData);
+ CHECK_RETURN_VALUE(xglGetQueryPoolResults);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetFormatInfo:
+ {
+ struct_xglGetFormatInfo* pPacket = interpret_body_as_xglGetFormatInfo(packet);
+ XGL_SIZE size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData == NULL)
+ {
+ glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglGetFormatInfo);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateImage:
+ {
+ struct_xglCreateImage* pPacket = interpret_body_as_xglCreateImage(packet);
+ XGL_IMAGE image;
+ replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &image);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pImage, &image);
+ }
+ CHECK_RETURN_VALUE(xglCreateImage);
+ break;
+ }
+ case GLV_TPI_XGL_xglGetImageSubresourceInfo:
+ {
+ struct_xglGetImageSubresourceInfo* pPacket = interpret_body_as_xglGetImageSubresourceInfo(packet);
+ XGL_SIZE size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData == NULL)
+ {
+ glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglGetImageSubresourceInfo);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateImageView:
+ {
+ struct_xglCreateImageView* pPacket = interpret_body_as_xglCreateImageView(packet);
+ XGL_IMAGE_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_IMAGE_VIEW_CREATE_INFO));
+ createInfo.image = remap(pPacket->pCreateInfo->image);
+ XGL_IMAGE_VIEW imageView;
+ replayResult = m_xglFuncs.real_xglCreateImageView(remap(pPacket->device), &createInfo, &imageView);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pView, &imageView);
+ }
+ CHECK_RETURN_VALUE(xglCreateImageView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateColorAttachmentView:
+ {
+ struct_xglCreateColorAttachmentView* pPacket = interpret_body_as_xglCreateColorAttachmentView(packet);
+ XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO));
+ createInfo.image = remap(pPacket->pCreateInfo->image);
+ XGL_COLOR_ATTACHMENT_VIEW ColorAttachmentView;
+ replayResult = m_xglFuncs.real_xglCreateColorAttachmentView(remap(pPacket->device), &createInfo, &ColorAttachmentView);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pView, &ColorAttachmentView);
+ }
+ CHECK_RETURN_VALUE(xglCreateColorAttachmentView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDepthStencilView:
+ {
+ struct_xglCreateDepthStencilView* pPacket = interpret_body_as_xglCreateDepthStencilView(packet);
+ XGL_DEPTH_STENCIL_VIEW_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO));
+ createInfo.image = remap(pPacket->pCreateInfo->image);
+ XGL_DEPTH_STENCIL_VIEW view;
+ replayResult = m_xglFuncs.real_xglCreateDepthStencilView(remap(pPacket->device), &createInfo, &view);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pView, &view);
+ }
+ CHECK_RETURN_VALUE(xglCreateDepthStencilView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateShader:
+ {
+ struct_xglCreateShader* pPacket = interpret_body_as_xglCreateShader(packet);
+ XGL_SHADER shader;
+ replayResult = m_xglFuncs.real_xglCreateShader(remap(pPacket->device), pPacket->pCreateInfo, &shader);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pShader, &shader);
+ }
+ CHECK_RETURN_VALUE(xglCreateShader);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateGraphicsPipeline:
+ {
+ struct_xglCreateGraphicsPipeline* pPacket = interpret_body_as_xglCreateGraphicsPipeline(packet);
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));
+ // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;
+ while ((NULL != pPacketNext) && (XGL_NULL_HANDLE != pPacketNext)) // TODO : Shouldn't need both of these checks
+ {
+ if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)
+ pNext->shader.shader = remap(pPacketNext->shader.shader);
+ // TODO : Do we need to do anything here for non-shader blocks?
+ pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;
+ pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;
+ }
+ XGL_PIPELINE pipeline;
+ replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pPipeline, &pipeline);
+ }
+ CHECK_RETURN_VALUE(xglCreateGraphicsPipeline);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateComputePipeline:
+ {
+ struct_xglCreateComputePipeline* pPacket = interpret_body_as_xglCreateComputePipeline(packet);
+ XGL_COMPUTE_PIPELINE_CREATE_INFO createInfo;
+ memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO));
+ createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);
+ XGL_PIPELINE pipeline;
+ replayResult = m_xglFuncs.real_xglCreateComputePipeline(remap(pPacket->device), &createInfo, &pipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pPipeline, &pipeline);
+ }
+ CHECK_RETURN_VALUE(xglCreateComputePipeline);
+ break;
+ }
+ case GLV_TPI_XGL_xglStorePipeline:
+ {
+ struct_xglStorePipeline* pPacket = interpret_body_as_xglStorePipeline(packet);
+ XGL_SIZE size = 0;
+ void* pData = NULL;
+ if (pPacket->pData != NULL && pPacket->pDataSize != NULL)
+ {
+ size = *pPacket->pDataSize;
+ pData = glv_malloc(*pPacket->pDataSize);
+ }
+ replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (size != *pPacket->pDataSize && pData == NULL)
+ {
+ glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
+ }
+ else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ {
+ glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\n");
+ }
+ }
+ glv_free(pData);
+ CHECK_RETURN_VALUE(xglStorePipeline);
+ break;
+ }
+ case GLV_TPI_XGL_xglLoadPipeline:
+ {
+ struct_xglLoadPipeline* pPacket = interpret_body_as_xglLoadPipeline(packet);
+ XGL_PIPELINE pipeline;
+ replayResult = m_xglFuncs.real_xglLoadPipeline(remap(pPacket->device), pPacket->dataSize, pPacket->pData, &pipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pPipeline, &pipeline);
+ }
+ CHECK_RETURN_VALUE(xglLoadPipeline);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreatePipelineDelta:
+ {
+ struct_xglCreatePipelineDelta* pPacket = interpret_body_as_xglCreatePipelineDelta(packet);
+ XGL_PIPELINE_DELTA pipeline;
+ replayResult = m_xglFuncs.real_xglCreatePipelineDelta(remap(pPacket->device), pPacket->p1, pPacket->p2, &pipeline);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->delta, &pipeline);
+ }
+ CHECK_RETURN_VALUE(xglCreatePipelineDelta);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateSampler:
+ {
+ struct_xglCreateSampler* pPacket = interpret_body_as_xglCreateSampler(packet);
+ XGL_SAMPLER sampler;
+ replayResult = m_xglFuncs.real_xglCreateSampler(remap(pPacket->device), pPacket->pCreateInfo, &sampler);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pSampler, &sampler);
+ }
+ CHECK_RETURN_VALUE(xglCreateSampler);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDescriptorSet:
+ {
+ struct_xglCreateDescriptorSet* pPacket = interpret_body_as_xglCreateDescriptorSet(packet);
+ XGL_DESCRIPTOR_SET descriptorSet;
+ replayResult = m_xglFuncs.real_xglCreateDescriptorSet(remap(pPacket->device), pPacket->pCreateInfo, &descriptorSet);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pDescriptorSet, &descriptorSet);
+ }
+ CHECK_RETURN_VALUE(xglCreateDescriptorSet);
+ break;
+ }
+ case GLV_TPI_XGL_xglBeginDescriptorSetUpdate:
+ {
+ struct_xglBeginDescriptorSetUpdate* pPacket = interpret_body_as_xglBeginDescriptorSetUpdate(packet);
+ m_xglFuncs.real_xglBeginDescriptorSetUpdate(remap(pPacket->descriptorSet));
+ break;
+ }
+ case GLV_TPI_XGL_xglEndDescriptorSetUpdate:
+ {
+ struct_xglEndDescriptorSetUpdate* pPacket = interpret_body_as_xglEndDescriptorSetUpdate(packet);
+ m_xglFuncs.real_xglEndDescriptorSetUpdate(remap(pPacket->descriptorSet));
+ break;
+ }
+ case GLV_TPI_XGL_xglAttachSamplerDescriptors:
+ {
+ struct_xglAttachSamplerDescriptors* pPacket = interpret_body_as_xglAttachSamplerDescriptors(packet);
+ XGL_SAMPLER* pSamplers = GLV_NEW_ARRAY(XGL_SAMPLER, pPacket->slotCount);
+ memcpy(pSamplers, pPacket->pSamplers, pPacket->slotCount * sizeof(XGL_SAMPLER));
+ for (XGL_UINT i = 0; i < pPacket->slotCount; i++)
+ {
+ pSamplers[i] = remap(pPacket->pSamplers[i]);
+ }
+ m_xglFuncs.real_xglAttachSamplerDescriptors(remap(pPacket->descriptorSet), pPacket->startSlot, pPacket->slotCount, pSamplers);
+ GLV_DELETE(pSamplers);
+ break;
+ }
+ case GLV_TPI_XGL_xglAttachImageViewDescriptors:
+ {
+ struct_xglAttachImageViewDescriptors* pPacket = interpret_body_as_xglAttachImageViewDescriptors(packet);
+ XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews = GLV_NEW_ARRAY(XGL_IMAGE_VIEW_ATTACH_INFO, pPacket->slotCount);
+ memcpy(pImageViews, pPacket->pImageViews, pPacket->slotCount * sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));
+ for (XGL_UINT i = 0; i < pPacket->slotCount; i++)
+ {
+ pImageViews[i].view = remap(pPacket->pImageViews[i].view);
+ }
+ m_xglFuncs.real_xglAttachImageViewDescriptors(remap(pPacket->descriptorSet), pPacket->startSlot, pPacket->slotCount, pImageViews);
+ GLV_DELETE(pImageViews);
+ break;
+ }
+ case GLV_TPI_XGL_xglAttachMemoryViewDescriptors:
+ {
+ struct_xglAttachMemoryViewDescriptors* pPacket = interpret_body_as_xglAttachMemoryViewDescriptors(packet);
+ XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews = GLV_NEW_ARRAY(XGL_MEMORY_VIEW_ATTACH_INFO, pPacket->slotCount);
+ memcpy(pMemViews, pPacket->pMemViews, pPacket->slotCount * sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));
+ for (XGL_UINT i = 0; i < pPacket->slotCount; i++)
+ {
+ pMemViews[i].mem = remap(pPacket->pMemViews[i].mem);
+ }
+ m_xglFuncs.real_xglAttachMemoryViewDescriptors(remap(pPacket->descriptorSet), pPacket->startSlot, pPacket->slotCount, pMemViews);
+ GLV_DELETE(pMemViews);
+ break;
+ }
+ case GLV_TPI_XGL_xglAttachNestedDescriptors:
+ {
+ struct_xglAttachNestedDescriptors* pPacket = interpret_body_as_xglAttachNestedDescriptors(packet);
+ XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets = GLV_NEW_ARRAY(XGL_DESCRIPTOR_SET_ATTACH_INFO, pPacket->slotCount);
+ memcpy(pNestedDescriptorSets, pPacket->pNestedDescriptorSets, pPacket->slotCount * sizeof(XGL_DESCRIPTOR_SET_ATTACH_INFO));
+ for (XGL_UINT i = 0; i < pPacket->slotCount; i++)
+ {
+ pNestedDescriptorSets[i].descriptorSet = remap(pPacket->pNestedDescriptorSets[i].descriptorSet);
+ }
+ m_xglFuncs.real_xglAttachNestedDescriptors(remap(pPacket->descriptorSet), pPacket->startSlot, pPacket->slotCount, pNestedDescriptorSets);
+ GLV_DELETE(pNestedDescriptorSets);
+ break;
+ }
+ case GLV_TPI_XGL_xglClearDescriptorSetSlots:
+ {
+ struct_xglClearDescriptorSetSlots* pPacket = interpret_body_as_xglClearDescriptorSetSlots(packet);
+ m_xglFuncs.real_xglClearDescriptorSetSlots(remap(pPacket->descriptorSet), pPacket->startSlot, pPacket->slotCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateViewportState:
+ {
+ struct_xglCreateViewportState* pPacket = interpret_body_as_xglCreateViewportState(packet);
+ XGL_VIEWPORT_STATE_OBJECT state;
+ replayResult = m_xglFuncs.real_xglCreateViewportState(remap(pPacket->device), pPacket->pCreateInfo, &state);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pState, &state);
+ }
+ CHECK_RETURN_VALUE(xglCreateViewportState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateRasterState:
+ {
+ struct_xglCreateRasterState* pPacket = interpret_body_as_xglCreateRasterState(packet);
+ XGL_RASTER_STATE_OBJECT state;
+ replayResult = m_xglFuncs.real_xglCreateRasterState(remap(pPacket->device), pPacket->pCreateInfo, &state);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pState, &state);
+ }
+ CHECK_RETURN_VALUE(xglCreateRasterState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateMsaaState:
+ {
+ struct_xglCreateMsaaState* pPacket = interpret_body_as_xglCreateMsaaState(packet);
+ XGL_MSAA_STATE_OBJECT state;
+ replayResult = m_xglFuncs.real_xglCreateMsaaState(remap(pPacket->device), pPacket->pCreateInfo, &state);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pState, &state);
+ }
+ CHECK_RETURN_VALUE(xglCreateMsaaState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateColorBlendState:
+ {
+ struct_xglCreateColorBlendState* pPacket = interpret_body_as_xglCreateColorBlendState(packet);
+ XGL_COLOR_BLEND_STATE_OBJECT state;
+ replayResult = m_xglFuncs.real_xglCreateColorBlendState(remap(pPacket->device), pPacket->pCreateInfo, &state);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pState, &state);
+ }
+ CHECK_RETURN_VALUE(xglCreateColorBlendState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateDepthStencilState:
+ {
+ struct_xglCreateDepthStencilState* pPacket = interpret_body_as_xglCreateDepthStencilState(packet);
+ XGL_DEPTH_STENCIL_STATE_OBJECT state;
+ replayResult = m_xglFuncs.real_xglCreateDepthStencilState(remap(pPacket->device), pPacket->pCreateInfo, &state);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pState, &state);
+ }
+ CHECK_RETURN_VALUE(xglCreateDepthStencilState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCreateCommandBuffer:
+ {
+ struct_xglCreateCommandBuffer* pPacket = interpret_body_as_xglCreateCommandBuffer(packet);
+ XGL_CMD_BUFFER cmdBuffer;
+ replayResult = m_xglFuncs.real_xglCreateCommandBuffer(remap(pPacket->device), pPacket->pCreateInfo, &cmdBuffer);
+ if (replayResult == XGL_SUCCESS)
+ {
+ add_to_map(pPacket->pCmdBuffer, &cmdBuffer);
+ }
+ CHECK_RETURN_VALUE(xglCreateCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglBeginCommandBuffer:
+ {
+ struct_xglBeginCommandBuffer* pPacket = interpret_body_as_xglBeginCommandBuffer(packet);
+ replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->flags);
+ CHECK_RETURN_VALUE(xglBeginCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglEndCommandBuffer:
+ {
+ struct_xglEndCommandBuffer* pPacket = interpret_body_as_xglEndCommandBuffer(packet);
+ replayResult = m_xglFuncs.real_xglEndCommandBuffer(remap(pPacket->cmdBuffer));
+ CHECK_RETURN_VALUE(xglEndCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglResetCommandBuffer:
+ {
+ struct_xglResetCommandBuffer* pPacket = interpret_body_as_xglResetCommandBuffer(packet);
+ replayResult = m_xglFuncs.real_xglResetCommandBuffer(remap(pPacket->cmdBuffer));
+ CHECK_RETURN_VALUE(xglResetCommandBuffer);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindPipeline:
+ {
+ struct_xglCmdBindPipeline* pPacket = interpret_body_as_xglCmdBindPipeline(packet);
+ m_xglFuncs.real_xglCmdBindPipeline(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, remap(pPacket->pipeline));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindPipelineDelta:
+ {
+ struct_xglCmdBindPipelineDelta* pPacket = interpret_body_as_xglCmdBindPipelineDelta(packet);
+ m_xglFuncs.real_xglCmdBindPipelineDelta(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, remap(pPacket->delta));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindStateObject:
+ {
+ struct_xglCmdBindStateObject* pPacket = interpret_body_as_xglCmdBindStateObject(packet);
+ m_xglFuncs.real_xglCmdBindStateObject(remap(pPacket->cmdBuffer), pPacket->stateBindPoint, remap(pPacket->state));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindDescriptorSet:
+ {
+ struct_xglCmdBindDescriptorSet* pPacket = interpret_body_as_xglCmdBindDescriptorSet(packet);
+ m_xglFuncs.real_xglCmdBindDescriptorSet(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->index, remap(pPacket->descriptorSet), pPacket->slotOffset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindDynamicMemoryView:
+ {
+ struct_xglCmdBindDynamicMemoryView* pPacket = interpret_body_as_xglCmdBindDynamicMemoryView(packet);
+ XGL_MEMORY_VIEW_ATTACH_INFO memView;
+ memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));
+ memView.mem = remap(pPacket->pMemView->mem);
+ m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindIndexData:
+ {
+ struct_xglCmdBindIndexData* pPacket = interpret_body_as_xglCmdBindIndexData(packet);
+ m_xglFuncs.real_xglCmdBindIndexData(remap(pPacket->cmdBuffer), remap(pPacket->mem), pPacket->offset, pPacket->indexType);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBindAttachments:
+ {
+ struct_xglCmdBindAttachments* pPacket = interpret_body_as_xglCmdBindAttachments(packet);
+ // adjust color targets
+ XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pPacket->pColorAttachments;
+ bool allocatedColorAttachments = false;
+ if (pColorAttachments != NULL)
+ {
+ allocatedColorAttachments = true;
+ pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pPacket->colorAttachmentCount);
+ memcpy(pColorAttachments, pPacket->pColorAttachments, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pPacket->colorAttachmentCount);
+ for (XGL_UINT i = 0; i < pPacket->colorAttachmentCount; i++)
+ {
+ pColorAttachments[i].view = remap(pPacket->pColorAttachments[i].view);
+ }
+ }
+
+ // adjust depth stencil target
+ const XGL_DEPTH_STENCIL_BIND_INFO* pDepthAttachment = pPacket->pDepthAttachment;
+ XGL_DEPTH_STENCIL_BIND_INFO depthTarget;
+ if (pDepthAttachment != NULL)
+ {
+ memcpy(&depthTarget, pPacket->pDepthAttachment, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));
+ depthTarget.view = remap(pPacket->pDepthAttachment->view);
+ pDepthAttachment = &depthTarget;
+ }
+
+ // make call
+ m_xglFuncs.real_xglCmdBindAttachments(remap(pPacket->cmdBuffer), pPacket->colorAttachmentCount, pColorAttachments, pDepthAttachment);
+
+ // cleanup
+ if (allocatedColorAttachments)
+ {
+ GLV_DELETE((void*)pColorAttachments);
+ }
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdPrepareMemoryRegions:
+ {
+ struct_xglCmdPrepareMemoryRegions* pPacket = interpret_body_as_xglCmdPrepareMemoryRegions(packet);
+ // adjust transitions
+ XGL_MEMORY_STATE_TRANSITION* pStateTransitions = (XGL_MEMORY_STATE_TRANSITION*)pPacket->pStateTransitions;
+ bool allocatedMem = false;
+ if (pStateTransitions != NULL)
+ {
+ allocatedMem = true;
+ pStateTransitions = GLV_NEW_ARRAY(XGL_MEMORY_STATE_TRANSITION, pPacket->transitionCount);
+ memcpy(pStateTransitions, pPacket->pStateTransitions, sizeof(XGL_MEMORY_STATE_TRANSITION) * pPacket->transitionCount);
+ for (XGL_UINT i = 0; i < pPacket->transitionCount; i++)
+ {
+ pStateTransitions[i].mem = remap(pPacket->pStateTransitions[i].mem);
+ }
+ }
+
+ m_xglFuncs.real_xglCmdPrepareMemoryRegions(remap(pPacket->cmdBuffer), pPacket->transitionCount, pStateTransitions);
+
+ // cleanup
+ if (allocatedMem)
+ {
+ GLV_DELETE((void*)pStateTransitions);
+ }
+
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdPrepareImages:
+ {
+ struct_xglCmdPrepareImages* pPacket = interpret_body_as_xglCmdPrepareImages(packet);
+
+ // adjust transitions
+ XGL_IMAGE_STATE_TRANSITION* pStateTransitions = (XGL_IMAGE_STATE_TRANSITION*)pPacket->pStateTransitions;
+ bool allocatedMem = false;
+ if (pStateTransitions != NULL)
+ {
+ allocatedMem = true;
+ pStateTransitions = GLV_NEW_ARRAY(XGL_IMAGE_STATE_TRANSITION, pPacket->transitionCount);
+ memcpy(pStateTransitions, pPacket->pStateTransitions, sizeof(XGL_IMAGE_STATE_TRANSITION) * pPacket->transitionCount);
+ for (XGL_UINT i = 0; i < pPacket->transitionCount; i++)
+ {
+ pStateTransitions[i].image = remap(pPacket->pStateTransitions[i].image);
+ }
+ }
+
+ m_xglFuncs.real_xglCmdPrepareImages(remap(pPacket->cmdBuffer), pPacket->transitionCount, pStateTransitions);
+
+ // cleanup
+ if (allocatedMem)
+ {
+ GLV_DELETE((void*)pStateTransitions);
+ }
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDraw:
+ {
+ struct_xglCmdDraw* pPacket = interpret_body_as_xglCmdDraw(packet);
+ m_xglFuncs.real_xglCmdDraw(remap(pPacket->cmdBuffer), pPacket->firstVertex, pPacket->vertexCount, pPacket->firstInstance, pPacket->instanceCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDrawIndexed:
+ {
+ struct_xglCmdDrawIndexed* pPacket = interpret_body_as_xglCmdDrawIndexed(packet);
+ m_xglFuncs.real_xglCmdDrawIndexed(remap(pPacket->cmdBuffer), pPacket->firstIndex, pPacket->indexCount, pPacket->vertexOffset, pPacket->firstInstance, pPacket->instanceCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDrawIndirect:
+ {
+ struct_xglCmdDrawIndirect* pPacket = interpret_body_as_xglCmdDrawIndirect(packet);
+ m_xglFuncs.real_xglCmdDrawIndirect(remap(pPacket->cmdBuffer), remap(pPacket->mem), pPacket->offset, pPacket->count, pPacket->stride);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
+ {
+ struct_xglCmdDrawIndexedIndirect* pPacket = interpret_body_as_xglCmdDrawIndexedIndirect(packet);
+ m_xglFuncs.real_xglCmdDrawIndexedIndirect(remap(pPacket->cmdBuffer), remap(pPacket->mem), pPacket->offset, pPacket->count, pPacket->stride);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDispatch:
+ {
+ struct_xglCmdDispatch* pPacket = interpret_body_as_xglCmdDispatch(packet);
+ m_xglFuncs.real_xglCmdDispatch(remap(pPacket->cmdBuffer), pPacket->x, pPacket->y, pPacket->z);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDispatchIndirect:
+ {
+ struct_xglCmdDispatchIndirect* pPacket = interpret_body_as_xglCmdDispatchIndirect(packet);
+ m_xglFuncs.real_xglCmdDispatchIndirect(remap(pPacket->cmdBuffer), remap(pPacket->mem), pPacket->offset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyMemory:
+ {
+ struct_xglCmdCopyMemory* pPacket = interpret_body_as_xglCmdCopyMemory(packet);
+ m_xglFuncs.real_xglCmdCopyMemory(remap(pPacket->cmdBuffer), remap(pPacket->srcMem), remap(pPacket->destMem), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyImage:
+ {
+ struct_xglCmdCopyImage* pPacket = interpret_body_as_xglCmdCopyImage(packet);
+ m_xglFuncs.real_xglCmdCopyImage(remap(pPacket->cmdBuffer), remap(pPacket->srcImage), remap(pPacket->destImage), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyMemoryToImage:
+ {
+ struct_xglCmdCopyMemoryToImage* pPacket = interpret_body_as_xglCmdCopyMemoryToImage(packet);
+ m_xglFuncs.real_xglCmdCopyMemoryToImage(remap(pPacket->cmdBuffer), remap(pPacket->srcMem), remap(pPacket->destImage), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCopyImageToMemory:
+ {
+ struct_xglCmdCopyImageToMemory* pPacket = interpret_body_as_xglCmdCopyImageToMemory(packet);
+ m_xglFuncs.real_xglCmdCopyImageToMemory(remap(pPacket->cmdBuffer), remap(pPacket->srcImage), remap(pPacket->destMem), pPacket->regionCount, pPacket->pRegions);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdCloneImageData:
+ {
+ struct_xglCmdCloneImageData* pPacket = interpret_body_as_xglCmdCloneImageData(packet);
+ m_xglFuncs.real_xglCmdCloneImageData(remap(pPacket->cmdBuffer), remap(pPacket->srcImage), pPacket->srcImageState, remap(pPacket->destImage), pPacket->destImageState);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdUpdateMemory:
+ {
+ struct_xglCmdUpdateMemory* pPacket = interpret_body_as_xglCmdUpdateMemory(packet);
+ m_xglFuncs.real_xglCmdUpdateMemory(remap(pPacket->cmdBuffer), remap(pPacket->destMem), pPacket->destOffset, pPacket->dataSize, pPacket->pData);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdFillMemory:
+ {
+ struct_xglCmdFillMemory* pPacket = interpret_body_as_xglCmdFillMemory(packet);
+ m_xglFuncs.real_xglCmdFillMemory(remap(pPacket->cmdBuffer), remap(pPacket->destMem), pPacket->destOffset, pPacket->fillSize, pPacket->data);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdClearColorImage:
+ {
+ struct_xglCmdClearColorImage* pPacket = interpret_body_as_xglCmdClearColorImage(packet);
+ m_xglFuncs.real_xglCmdClearColorImage(remap(pPacket->cmdBuffer), remap(pPacket->image), pPacket->color, pPacket->rangeCount, pPacket->pRanges);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdClearColorImageRaw:
+ {
+ struct_xglCmdClearColorImageRaw* pPacket = interpret_body_as_xglCmdClearColorImageRaw(packet);
+ m_xglFuncs.real_xglCmdClearColorImageRaw(remap(pPacket->cmdBuffer), remap(pPacket->image), pPacket->color, pPacket->rangeCount, pPacket->pRanges);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdClearDepthStencil:
+ {
+ struct_xglCmdClearDepthStencil* pPacket = interpret_body_as_xglCmdClearDepthStencil(packet);
+ m_xglFuncs.real_xglCmdClearDepthStencil(remap(pPacket->cmdBuffer), remap(pPacket->image), pPacket->depth, pPacket->stencil, pPacket->rangeCount, pPacket->pRanges);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdResolveImage:
+ {
+ struct_xglCmdResolveImage* pPacket = interpret_body_as_xglCmdResolveImage(packet);
+ m_xglFuncs.real_xglCmdResolveImage(remap(pPacket->cmdBuffer), remap(pPacket->srcImage), remap(pPacket->destImage), pPacket->rectCount, pPacket->pRects);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdSetEvent:
+ {
+ struct_xglCmdSetEvent* pPacket = interpret_body_as_xglCmdSetEvent(packet);
+ m_xglFuncs.real_xglCmdSetEvent(remap(pPacket->cmdBuffer), remap(pPacket->event));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdResetEvent:
+ {
+ struct_xglCmdResetEvent* pPacket = interpret_body_as_xglCmdResetEvent(packet);
+ m_xglFuncs.real_xglCmdResetEvent(remap(pPacket->cmdBuffer), remap(pPacket->event));
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdMemoryAtomic:
+ {
+ struct_xglCmdMemoryAtomic* pPacket = interpret_body_as_xglCmdMemoryAtomic(packet);
+ m_xglFuncs.real_xglCmdMemoryAtomic(remap(pPacket->cmdBuffer), remap(pPacket->destMem), pPacket->destOffset, pPacket->srcData, pPacket->atomicOp);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdBeginQuery:
+ {
+ struct_xglCmdBeginQuery* pPacket = interpret_body_as_xglCmdBeginQuery(packet);
+ m_xglFuncs.real_xglCmdBeginQuery(remap(pPacket->cmdBuffer), remap(pPacket->queryPool), pPacket->slot, pPacket->flags);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdEndQuery:
+ {
+ struct_xglCmdEndQuery* pPacket = interpret_body_as_xglCmdEndQuery(packet);
+ m_xglFuncs.real_xglCmdEndQuery(remap(pPacket->cmdBuffer), remap(pPacket->queryPool), pPacket->slot);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdResetQueryPool:
+ {
+ struct_xglCmdResetQueryPool* pPacket = interpret_body_as_xglCmdResetQueryPool(packet);
+ m_xglFuncs.real_xglCmdResetQueryPool(remap(pPacket->cmdBuffer), remap(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdWriteTimestamp:
+ {
+ struct_xglCmdWriteTimestamp* pPacket = interpret_body_as_xglCmdWriteTimestamp(packet);
+ m_xglFuncs.real_xglCmdWriteTimestamp(remap(pPacket->cmdBuffer), pPacket->timestampType, remap(pPacket->destMem), pPacket->destOffset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdInitAtomicCounters:
+ {
+ struct_xglCmdInitAtomicCounters* pPacket = interpret_body_as_xglCmdInitAtomicCounters(packet);
+ m_xglFuncs.real_xglCmdInitAtomicCounters(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->startCounter, pPacket->counterCount, pPacket->pData);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
+ {
+ struct_xglCmdLoadAtomicCounters* pPacket = interpret_body_as_xglCmdLoadAtomicCounters(packet);
+ m_xglFuncs.real_xglCmdLoadAtomicCounters(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->startCounter, pPacket->counterCount, pPacket->srcMem, pPacket->srcOffset);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
+ {
+ struct_xglCmdSaveAtomicCounters* pPacket = interpret_body_as_xglCmdSaveAtomicCounters(packet);
+ m_xglFuncs.real_xglCmdSaveAtomicCounters(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, pPacket->startCounter, pPacket->counterCount, remap(pPacket->destMem), pPacket->destOffset);
+ break;
+ }
+
+ // xglDbg.h functions
+ case GLV_TPI_XGL_xglDbgSetValidationLevel:
+ {
+ struct_xglDbgSetValidationLevel *pPacket = interpret_body_as_xglDbgSetValidationLevel(packet);
+ replayResult = m_xglFuncs.real_xglDbgSetValidationLevel(remap(pPacket->device), pPacket->validationLevel);
+ CHECK_RETURN_VALUE(xglDbgSetValidationLevel);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
+ {
+ struct_xglDbgRegisterMsgCallback *pPacket = interpret_body_as_xglDbgRegisterMsgCallback(packet);
+ // just pass NULL since don't have replay pointer to app data
+ replayResult = m_xglFuncs.real_xglDbgRegisterMsgCallback(pPacket->pfnMsgCallback, NULL);
+ CHECK_RETURN_VALUE(xglDbgRegisterMsgCallback);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
+ {
+ struct_xglDbgUnregisterMsgCallback *pPacket = interpret_body_as_xglDbgUnregisterMsgCallback(packet);
+ replayResult = m_xglFuncs.real_xglDbgUnregisterMsgCallback(pPacket->pfnMsgCallback);
+ CHECK_RETURN_VALUE(xglDbgUnregisterMsgCallback);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetMessageFilter:
+ {
+ struct_xglDbgSetMessageFilter *pPacket = interpret_body_as_xglDbgSetMessageFilter(packet);
+ replayResult = m_xglFuncs.real_xglDbgSetMessageFilter(remap(pPacket->device), pPacket->msgCode, pPacket->filter);
+ CHECK_RETURN_VALUE(xglDbgSetMessageFilter);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetObjectTag:
+ {
+ struct_xglDbgSetObjectTag *pPacket = interpret_body_as_xglDbgSetObjectTag(packet);
+ replayResult = m_xglFuncs.real_xglDbgSetObjectTag(remap(pPacket->object), pPacket->tagSize, pPacket->pTag);
+ CHECK_RETURN_VALUE(xglDbgSetObjectTag);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetGlobalOption:
+ {
+ struct_xglDbgSetGlobalOption *pPacket = interpret_body_as_xglDbgSetGlobalOption(packet);
+ replayResult = m_xglFuncs.real_xglDbgSetGlobalOption(pPacket->dbgOption, pPacket->dataSize, pPacket->pData);
+ CHECK_RETURN_VALUE(xglDbgSetGlobalOption);
+ break;
+ }
+ case GLV_TPI_XGL_xglDbgSetDeviceOption:
+ {
+ struct_xglDbgSetDeviceOption *pPacket = interpret_body_as_xglDbgSetDeviceOption(packet);
+ replayResult = m_xglFuncs.real_xglDbgSetDeviceOption(remap(pPacket->device), pPacket->dbgOption, pPacket->dataSize, pPacket->pData);
+ CHECK_RETURN_VALUE(xglDbgSetDeviceOption);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
+ {
+ struct_xglCmdDbgMarkerBegin *pPacket = interpret_body_as_xglCmdDbgMarkerBegin(packet);
+ m_xglFuncs.real_xglCmdDbgMarkerBegin(remap(pPacket->cmdBuffer), pPacket->pMarker);
+ break;
+ }
+ case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
+ {
+ struct_xglCmdDbgMarkerEnd *pPacket = interpret_body_as_xglCmdDbgMarkerEnd(packet);
+ m_xglFuncs.real_xglCmdDbgMarkerEnd(remap(pPacket->cmdBuffer));
+ break;
+ }
+
+ // xglWsiX11Ext.h
+ case GLV_TPI_XGL_xglWsiX11AssociateConnection:
+ {
+ struct_xglWsiX11AssociateConnection *pPacket = interpret_body_as_xglWsiX11AssociateConnection(packet);
+ //associate with the replayers Wsi connection rather than tracers
+ replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));
+ CHECK_RETURN_VALUE(xglWsiX11AssociateConnection);
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11GetMSC:
+ {
+ struct_xglWsiX11GetMSC *pPacket = interpret_body_as_xglWsiX11GetMSC(packet);
+ replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), pPacket->crtc, pPacket->pMsc);
+ CHECK_RETURN_VALUE(xglWsiX11GetMSC);
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
+ {
+ struct_xglWsiX11CreatePresentableImage *pPacket = interpret_body_as_xglWsiX11CreatePresentableImage(packet);
+ XGL_IMAGE img;
+ XGL_GPU_MEMORY mem;
+ replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);
+ if (replayResult == XGL_SUCCESS)
+ {
+ if (pPacket->pImage != NULL)
+ add_to_map(pPacket->pImage, &img);
+ if(pPacket->pMem != NULL)
+ add_to_map(pPacket->pMem, &mem);
+ }
+ CHECK_RETURN_VALUE(xglWsiX11CreatePresentableImage);
+ break;
+ }
+ case GLV_TPI_XGL_xglWsiX11QueuePresent:
+ {
+ struct_xglWsiX11QueuePresent *pPacket = interpret_body_as_xglWsiX11QueuePresent(packet);
+ XGL_WSI_X11_PRESENT_INFO pInfo;
+ memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));
+ pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);
+ // use replayers Xcb window
+ pInfo.destWindow = m_display->m_XcbWindow;
+ replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));
+ CHECK_RETURN_VALUE(xglWsiX11QueuePresent);
+ break;
+ }
+ default:
+ glv_LogWarn("Unrecognized packet_id %u, skipping\n", packet->packet_id);
+ returnValue = glv_replay::GLV_REPLAY_INVALID_ID;
+ break;
+ }
+
+ return returnValue;
+}
+
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_replay.h b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_replay.h
new file mode 100644
index 0000000..7ff2e55
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl_replay.h
@@ -0,0 +1,1314 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include <set>
+#include <map>
+#include <vector>
+#include <xcb/xcb.h>
+
+#include "glvreplay_window.h"
+#include "glvreplay_factory.h"
+#include "glv_trace_packet_identifiers.h"
+
+#include "xgl/inc/xgl.h"
+#include "xgl/inc/xglDbg.h"
+#include "xgl/inc/xglWsiX11Ext.h"
+
+class ApiReplay {
+public:
+ virtual ~ApiReplay() { }
+
+ virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;
+ virtual int init(glv_replay::Display & disp) = 0;
+};
+
+class xglDisplay: public glv_replay::DisplayImp {
+friend class xglReplay;
+public:
+ xglDisplay();
+ ~xglDisplay();
+ int init(const unsigned int gpu_idx);
+ int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);
+ int create_window(const unsigned int width, const unsigned int height);
+ void resize_window(const unsigned int width, const unsigned int height);
+ void process_event();
+ // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}
+#if defined(WIN32)
+ HWND get_window_handle() { return m_windowHandle; }
+#endif
+private:
+ XGL_RESULT init_xgl(const unsigned int gpu_idx);
+ bool m_initedXGL;
+#if defined(WIN32)
+ HWND m_windowHandle;
+#elif defined(PLATFORM_LINUX)
+ XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;
+ xcb_screen_t *m_pXcbScreen;
+ xcb_window_t m_XcbWindow;
+#endif
+ unsigned int m_windowWidth;
+ unsigned int m_windowHeight;
+#if 0
+ XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];
+ XGL_UINT32 m_gpuCount;
+ unsigned int m_gpuIdx;
+ XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];
+ XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];
+#endif
+ std::vector<XGL_CHAR *>m_extensions;
+};
+
+typedef struct _XGLAllocInfo {
+ XGL_GPU_SIZE size;
+ XGL_VOID *pData;
+} XGLAllocInfo;
+
+struct xglFuncs {
+ void init_funcs(void * libHandle);
+ void *m_libHandle;
+
+ typedef XGL_RESULT( XGLAPI * type_xglInitAndEnumerateGpus)(
+ const XGL_APPLICATION_INFO* pAppInfo,
+ const XGL_ALLOC_CALLBACKS* pAllocCb,
+ XGL_UINT maxGpus,
+ XGL_UINT* pGpuCount,
+ XGL_PHYSICAL_GPU* pGpus);
+ type_xglInitAndEnumerateGpus real_xglInitAndEnumerateGpus;
+ typedef XGL_RESULT( XGLAPI * type_xglGetGpuInfo)(
+ XGL_PHYSICAL_GPU gpu,
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglGetGpuInfo real_xglGetGpuInfo;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateDevice)(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo,
+ XGL_DEVICE* pDevice);
+ type_xglCreateDevice real_xglCreateDevice;
+ typedef XGL_RESULT( XGLAPI * type_xglDestroyDevice)(XGL_DEVICE device);
+ type_xglDestroyDevice real_xglDestroyDevice;
+ typedef XGL_RESULT( XGLAPI * type_xglGetExtensionSupport)(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_CHAR* pExtName);
+ type_xglGetExtensionSupport real_xglGetExtensionSupport;
+ typedef XGL_RESULT( XGLAPI * type_xglGetDeviceQueue)(
+ XGL_DEVICE device,
+ XGL_QUEUE_TYPE queueType,
+ XGL_UINT queueIndex,
+ XGL_QUEUE* pQueue);
+ type_xglGetDeviceQueue real_xglGetDeviceQueue;
+ typedef XGL_RESULT( XGLAPI * type_xglQueueSubmit)(
+ XGL_QUEUE queue,
+ XGL_UINT cmdBufferCount,
+ const XGL_CMD_BUFFER* pCmdBuffers,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs,
+ XGL_FENCE fence);
+ type_xglQueueSubmit real_xglQueueSubmit;
+ typedef XGL_RESULT( XGLAPI * type_xglQueueSetGlobalMemReferences)(
+ XGL_QUEUE queue,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs);
+ type_xglQueueSetGlobalMemReferences real_xglQueueSetGlobalMemReferences;
+ typedef XGL_RESULT( XGLAPI * type_xglQueueWaitIdle)(XGL_QUEUE queue);
+ type_xglQueueWaitIdle real_xglQueueWaitIdle;
+ typedef XGL_RESULT( XGLAPI * type_xglDeviceWaitIdle)(XGL_DEVICE device);
+ type_xglDeviceWaitIdle real_xglDeviceWaitIdle;
+ typedef XGL_RESULT( XGLAPI * type_xglGetMemoryHeapCount)(
+ XGL_DEVICE device,
+ XGL_UINT* pCount);
+ type_xglGetMemoryHeapCount real_xglGetMemoryHeapCount;
+ typedef XGL_RESULT( XGLAPI * type_xglGetMemoryHeapInfo)(
+ XGL_DEVICE device,
+ XGL_UINT heapId,
+ XGL_MEMORY_HEAP_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglGetMemoryHeapInfo real_xglGetMemoryHeapInfo;
+ typedef XGL_RESULT( XGLAPI * type_xglAllocMemory)(
+ XGL_DEVICE device,
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
+ XGL_GPU_MEMORY* pMem);
+ type_xglAllocMemory real_xglAllocMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglFreeMemory)(XGL_GPU_MEMORY mem);
+ type_xglFreeMemory real_xglFreeMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglSetMemoryPriority)(
+ XGL_GPU_MEMORY mem,
+ XGL_MEMORY_PRIORITY priority);
+ type_xglSetMemoryPriority real_xglSetMemoryPriority;
+ typedef XGL_RESULT( XGLAPI * type_xglMapMemory)(
+ XGL_GPU_MEMORY mem,
+ XGL_FLAGS flags, // Reserved
+ XGL_VOID** ppData);
+ type_xglMapMemory real_xglMapMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglUnmapMemory)(XGL_GPU_MEMORY mem);
+ type_xglUnmapMemory real_xglUnmapMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglPinSystemMemory)(
+ XGL_DEVICE device,
+ const XGL_VOID* pSysMem,
+ XGL_SIZE memSize,
+ XGL_GPU_MEMORY* pMem);
+ type_xglPinSystemMemory real_xglPinSystemMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglRemapVirtualMemoryPages)(
+ XGL_DEVICE device,
+ XGL_UINT rangeCount,
+ const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
+ XGL_UINT preWaitSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
+ XGL_UINT postSignalSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
+ type_xglRemapVirtualMemoryPages real_xglRemapVirtualMemoryPages;
+ typedef XGL_RESULT( XGLAPI * type_xglGetMultiGpuCompatibility)(
+ XGL_PHYSICAL_GPU gpu0,
+ XGL_PHYSICAL_GPU gpu1,
+ XGL_GPU_COMPATIBILITY_INFO* pInfo);
+ type_xglGetMultiGpuCompatibility real_xglGetMultiGpuCompatibility;
+ typedef XGL_RESULT( XGLAPI * type_xglOpenSharedMemory)(
+ XGL_DEVICE device,
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem);
+ type_xglOpenSharedMemory real_xglOpenSharedMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglOpenSharedQueueSemaphore)(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore);
+ type_xglOpenSharedQueueSemaphore real_xglOpenSharedQueueSemaphore;
+ typedef XGL_RESULT( XGLAPI * type_xglOpenPeerMemory)(
+ XGL_DEVICE device,
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem);
+ type_xglOpenPeerMemory real_xglOpenPeerMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglOpenPeerImage)(
+ XGL_DEVICE device,
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem);
+ type_xglOpenPeerImage real_xglOpenPeerImage;
+ typedef XGL_RESULT( XGLAPI * type_xglDestroyObject)(XGL_OBJECT object);
+ type_xglDestroyObject real_xglDestroyObject;
+ typedef XGL_RESULT( XGLAPI * type_xglGetObjectInfo)(
+ XGL_BASE_OBJECT object,
+ XGL_OBJECT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglGetObjectInfo real_xglGetObjectInfo;
+ typedef XGL_RESULT( XGLAPI * type_xglBindObjectMemory)(
+ XGL_OBJECT object,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset);
+ type_xglBindObjectMemory real_xglBindObjectMemory;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateFence)(
+ XGL_DEVICE device,
+ const XGL_FENCE_CREATE_INFO* pCreateInfo,
+ XGL_FENCE* pFence);
+ type_xglCreateFence real_xglCreateFence;
+ typedef XGL_RESULT( XGLAPI * type_xglGetFenceStatus)(XGL_FENCE fence);
+ type_xglGetFenceStatus real_xglGetFenceStatus;
+ typedef XGL_RESULT( XGLAPI * type_xglWaitForFences)(
+ XGL_DEVICE device,
+ XGL_UINT fenceCount,
+ const XGL_FENCE* pFences,
+ XGL_BOOL waitAll,
+ XGL_UINT64 timeout);
+ type_xglWaitForFences real_xglWaitForFences;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateQueueSemaphore)(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore);
+ type_xglCreateQueueSemaphore real_xglCreateQueueSemaphore;
+ typedef XGL_RESULT( XGLAPI * type_xglSignalQueueSemaphore)(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore);
+ type_xglSignalQueueSemaphore real_xglSignalQueueSemaphore;
+ typedef XGL_RESULT( XGLAPI * type_xglWaitQueueSemaphore)(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore);
+ type_xglWaitQueueSemaphore real_xglWaitQueueSemaphore;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateEvent)(
+ XGL_DEVICE device,
+ const XGL_EVENT_CREATE_INFO* pCreateInfo,
+ XGL_EVENT* pEvent);
+ type_xglCreateEvent real_xglCreateEvent;
+ typedef XGL_RESULT( XGLAPI * type_xglGetEventStatus)(XGL_EVENT event);
+ type_xglGetEventStatus real_xglGetEventStatus;
+ typedef XGL_RESULT( XGLAPI * type_xglSetEvent)(XGL_EVENT event);
+ type_xglSetEvent real_xglSetEvent;
+ typedef XGL_RESULT( XGLAPI * type_xglResetEvent)(XGL_EVENT event);
+ type_xglResetEvent real_xglResetEvent;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateQueryPool)(
+ XGL_DEVICE device,
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ XGL_QUERY_POOL* pQueryPool);
+ type_xglCreateQueryPool real_xglCreateQueryPool;
+ typedef XGL_RESULT( XGLAPI * type_xglGetQueryPoolResults)(
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglGetQueryPoolResults real_xglGetQueryPoolResults;
+ typedef XGL_RESULT( XGLAPI * type_xglGetFormatInfo)(
+ XGL_DEVICE device,
+ XGL_FORMAT format,
+ XGL_FORMAT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglGetFormatInfo real_xglGetFormatInfo;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateImage)(
+ XGL_DEVICE device,
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage);
+ type_xglCreateImage real_xglCreateImage;
+ typedef XGL_RESULT( XGLAPI * type_xglGetImageSubresourceInfo)(
+ XGL_IMAGE image,
+ const XGL_IMAGE_SUBRESOURCE* pSubresource,
+ XGL_SUBRESOURCE_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglGetImageSubresourceInfo real_xglGetImageSubresourceInfo;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateImageView)(
+ XGL_DEVICE device,
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE_VIEW* pView);
+ type_xglCreateImageView real_xglCreateImageView;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateColorAttachmentView)(
+ XGL_DEVICE device,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_ATTACHMENT_VIEW* pView);
+ type_xglCreateColorAttachmentView real_xglCreateColorAttachmentView;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateDepthStencilView)(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_VIEW* pView);
+ type_xglCreateDepthStencilView real_xglCreateDepthStencilView;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateShader)(
+ XGL_DEVICE device,
+ const XGL_SHADER_CREATE_INFO* pCreateInfo,
+ XGL_SHADER* pShader);
+ type_xglCreateShader real_xglCreateShader;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateGraphicsPipeline)(
+ XGL_DEVICE device,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline);
+ type_xglCreateGraphicsPipeline real_xglCreateGraphicsPipeline;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateComputePipeline)(
+ XGL_DEVICE device,
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline);
+ type_xglCreateComputePipeline real_xglCreateComputePipeline;
+ typedef XGL_RESULT( XGLAPI * type_xglStorePipeline)(
+ XGL_PIPELINE pipeline,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+ type_xglStorePipeline real_xglStorePipeline;
+ typedef XGL_RESULT( XGLAPI * type_xglLoadPipeline)(
+ XGL_DEVICE device,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData,
+ XGL_PIPELINE* pPipeline);
+ type_xglLoadPipeline real_xglLoadPipeline;
+ typedef XGL_RESULT( XGLAPI * type_xglCreatePipelineDelta)(
+ XGL_DEVICE device,
+ XGL_PIPELINE p1,
+ XGL_PIPELINE p2,
+ XGL_PIPELINE_DELTA* delta);
+ type_xglCreatePipelineDelta real_xglCreatePipelineDelta;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateSampler)(
+ XGL_DEVICE device,
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
+ XGL_SAMPLER* pSampler);
+ type_xglCreateSampler real_xglCreateSampler;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateDescriptorSet)(
+ XGL_DEVICE device,
+ const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_SET* pDescriptorSet);
+ type_xglCreateDescriptorSet real_xglCreateDescriptorSet;
+ typedef XGL_VOID( XGLAPI * type_xglBeginDescriptorSetUpdate)(XGL_DESCRIPTOR_SET descriptorSet);
+ type_xglBeginDescriptorSetUpdate real_xglBeginDescriptorSetUpdate;
+ typedef XGL_VOID( XGLAPI * type_xglEndDescriptorSetUpdate)(XGL_DESCRIPTOR_SET descriptorSet);
+ type_xglEndDescriptorSetUpdate real_xglEndDescriptorSetUpdate;
+ typedef XGL_VOID( XGLAPI * type_xglAttachSamplerDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_SAMPLER* pSamplers);
+ type_xglAttachSamplerDescriptors real_xglAttachSamplerDescriptors;
+ typedef XGL_VOID( XGLAPI * type_xglAttachImageViewDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
+ type_xglAttachImageViewDescriptors real_xglAttachImageViewDescriptors;
+ typedef XGL_VOID( XGLAPI * type_xglAttachMemoryViewDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
+ type_xglAttachMemoryViewDescriptors real_xglAttachMemoryViewDescriptors;
+ typedef XGL_VOID( XGLAPI * type_xglAttachNestedDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
+ type_xglAttachNestedDescriptors real_xglAttachNestedDescriptors;
+ typedef XGL_VOID( XGLAPI * type_xglClearDescriptorSetSlots)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount);
+ type_xglClearDescriptorSetSlots real_xglClearDescriptorSetSlots;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateViewportState)(
+ XGL_DEVICE device,
+ const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
+ XGL_VIEWPORT_STATE_OBJECT* pState);
+ type_xglCreateViewportState real_xglCreateViewportState;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateRasterState)(
+ XGL_DEVICE device,
+ const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
+ XGL_RASTER_STATE_OBJECT* pState);
+ type_xglCreateRasterState real_xglCreateRasterState;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateMsaaState)(
+ XGL_DEVICE device,
+ const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
+ XGL_MSAA_STATE_OBJECT* pState);
+ type_xglCreateMsaaState real_xglCreateMsaaState;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateColorBlendState)(
+ XGL_DEVICE device,
+ const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_BLEND_STATE_OBJECT* pState);
+ type_xglCreateColorBlendState real_xglCreateColorBlendState;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateDepthStencilState)(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+ type_xglCreateDepthStencilState real_xglCreateDepthStencilState;
+ typedef XGL_RESULT( XGLAPI * type_xglCreateCommandBuffer)(
+ XGL_DEVICE device,
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_CMD_BUFFER* pCmdBuffer);
+ type_xglCreateCommandBuffer real_xglCreateCommandBuffer;
+ typedef XGL_RESULT( XGLAPI * type_xglBeginCommandBuffer)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_FLAGS flags);
+ type_xglBeginCommandBuffer real_xglBeginCommandBuffer;
+ typedef XGL_RESULT( XGLAPI * type_xglEndCommandBuffer)(XGL_CMD_BUFFER cmdBuffer);
+ type_xglEndCommandBuffer real_xglEndCommandBuffer;
+ typedef XGL_RESULT( XGLAPI * type_xglResetCommandBuffer)(XGL_CMD_BUFFER cmdBuffer);
+ type_xglResetCommandBuffer real_xglResetCommandBuffer;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindPipeline)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE pipeline);
+ type_xglCmdBindPipeline real_xglCmdBindPipeline;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindPipelineDelta)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE_DELTA delta);
+ type_xglCmdBindPipelineDelta real_xglCmdBindPipelineDelta;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindStateObject)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_STATE_BIND_POINT stateBindPoint,
+ XGL_STATE_OBJECT state);
+ type_xglCmdBindStateObject real_xglCmdBindStateObject;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindDescriptorSet)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT index,
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT slotOffset);
+ type_xglCmdBindDescriptorSet real_xglCmdBindDescriptorSet;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindDynamicMemoryView)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
+ type_xglCmdBindDynamicMemoryView real_xglCmdBindDynamicMemoryView;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindIndexData)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_INDEX_TYPE indexType);
+ type_xglCmdBindIndexData real_xglCmdBindIndexData;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBindAttachments)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT colorTargetCount,
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorTargets,
+ const XGL_DEPTH_STENCIL_BIND_INFO* pDepthTarget);
+ type_xglCmdBindAttachments real_xglCmdBindAttachments;
+ typedef XGL_VOID( XGLAPI * type_xglCmdPrepareMemoryRegions)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
+ type_xglCmdPrepareMemoryRegions real_xglCmdPrepareMemoryRegions;
+ typedef XGL_VOID( XGLAPI * type_xglCmdPrepareImages)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
+ type_xglCmdPrepareImages real_xglCmdPrepareImages;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDraw)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstVertex,
+ XGL_UINT vertexCount,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount);
+ type_xglCmdDraw real_xglCmdDraw;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDrawIndexed)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstIndex,
+ XGL_UINT indexCount,
+ XGL_INT vertexOffset,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount);
+ type_xglCmdDrawIndexed real_xglCmdDrawIndexed;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDrawIndirect)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride);
+ type_xglCmdDrawIndirect real_xglCmdDrawIndirect;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDrawIndexedIndirect)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride);
+ type_xglCmdDrawIndexedIndirect real_xglCmdDrawIndexedIndirect;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDispatch)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT x,
+ XGL_UINT y,
+ XGL_UINT z);
+ type_xglCmdDispatch real_xglCmdDispatch;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDispatchIndirect)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset);
+ type_xglCmdDispatchIndirect real_xglCmdDispatchIndirect;
+ typedef XGL_VOID( XGLAPI * type_xglCmdCopyMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_COPY* pRegions);
+ type_xglCmdCopyMemory real_xglCmdCopyMemory;
+ typedef XGL_VOID( XGLAPI * type_xglCmdCopyImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_IMAGE_COPY* pRegions);
+ type_xglCmdCopyImage real_xglCmdCopyImage;
+ typedef XGL_VOID( XGLAPI * type_xglCmdCopyMemoryToImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions);
+ type_xglCmdCopyMemoryToImage real_xglCmdCopyMemoryToImage;
+ typedef XGL_VOID( XGLAPI * type_xglCmdCopyImageToMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions);
+ type_xglCmdCopyImageToMemory real_xglCmdCopyImageToMemory;
+ typedef XGL_VOID( XGLAPI * type_xglCmdCloneImageData)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE_STATE srcImageState,
+ XGL_IMAGE destImage,
+ XGL_IMAGE_STATE destImageState);
+ type_xglCmdCloneImageData real_xglCmdCloneImageData;
+ typedef XGL_VOID( XGLAPI * type_xglCmdUpdateMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE dataSize,
+ const XGL_UINT32* pData);
+ type_xglCmdUpdateMemory real_xglCmdUpdateMemory;
+ typedef XGL_VOID( XGLAPI * type_xglCmdFillMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE fillSize,
+ XGL_UINT32 data);
+ type_xglCmdFillMemory real_xglCmdFillMemory;
+ typedef XGL_VOID( XGLAPI * type_xglCmdClearColorImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_FLOAT color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+ type_xglCmdClearColorImage real_xglCmdClearColorImage;
+ typedef XGL_VOID( XGLAPI * type_xglCmdClearColorImageRaw)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_UINT32 color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+ type_xglCmdClearColorImageRaw real_xglCmdClearColorImageRaw;
+ typedef XGL_VOID( XGLAPI * type_xglCmdClearDepthStencil)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ XGL_FLOAT depth,
+ XGL_UINT32 stencil,
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+ type_xglCmdClearDepthStencil real_xglCmdClearDepthStencil;
+ typedef XGL_VOID( XGLAPI * type_xglCmdResolveImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT rectCount,
+ const XGL_IMAGE_RESOLVE* pRects);
+ type_xglCmdResolveImage real_xglCmdResolveImage;
+ typedef XGL_VOID( XGLAPI * type_xglCmdSetEvent)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event);
+ type_xglCmdSetEvent real_xglCmdSetEvent;
+ typedef XGL_VOID( XGLAPI * type_xglCmdResetEvent)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event);
+ type_xglCmdResetEvent real_xglCmdResetEvent;
+ typedef XGL_VOID( XGLAPI * type_xglCmdMemoryAtomic)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_UINT64 srcData,
+ XGL_ATOMIC_OP atomicOp);
+ type_xglCmdMemoryAtomic real_xglCmdMemoryAtomic;
+ typedef XGL_VOID( XGLAPI * type_xglCmdBeginQuery)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot,
+ XGL_FLAGS flags);
+ type_xglCmdBeginQuery real_xglCmdBeginQuery;
+ typedef XGL_VOID( XGLAPI * type_xglCmdEndQuery)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot);
+ type_xglCmdEndQuery real_xglCmdEndQuery;
+ typedef XGL_VOID( XGLAPI * type_xglCmdResetQueryPool)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount);
+ type_xglCmdResetQueryPool real_xglCmdResetQueryPool;
+ typedef XGL_VOID( XGLAPI * type_xglCmdWriteTimestamp)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_TIMESTAMP_TYPE timestampType,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset);
+ type_xglCmdWriteTimestamp real_xglCmdWriteTimestamp;
+ typedef XGL_VOID( XGLAPI * type_xglCmdInitAtomicCounters)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ const XGL_UINT32* pData);
+ type_xglCmdInitAtomicCounters real_xglCmdInitAtomicCounters;
+ typedef XGL_VOID( XGLAPI * type_xglCmdLoadAtomicCounters)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_SIZE srcOffset);
+ type_xglCmdLoadAtomicCounters real_xglCmdLoadAtomicCounters;
+ typedef XGL_VOID( XGLAPI * type_xglCmdSaveAtomicCounters)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset);
+ type_xglCmdSaveAtomicCounters real_xglCmdSaveAtomicCounters;
+
+ // Debug entrypoints
+ typedef XGL_RESULT( XGLAPI * type_xglDbgSetValidationLevel)(
+ XGL_DEVICE device,
+ XGL_VALIDATION_LEVEL validationLevel);
+ type_xglDbgSetValidationLevel real_xglDbgSetValidationLevel;
+ typedef XGL_RESULT( XGLAPI * type_xglDbgRegisterMsgCallback)(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ XGL_VOID* pUserData);
+ type_xglDbgRegisterMsgCallback real_xglDbgRegisterMsgCallback;
+ typedef XGL_RESULT( XGLAPI * type_xglDbgUnregisterMsgCallback)(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
+ type_xglDbgUnregisterMsgCallback real_xglDbgUnregisterMsgCallback;
+ typedef XGL_RESULT( XGLAPI * type_xglDbgSetMessageFilter)(
+ XGL_DEVICE device,
+ XGL_INT msgCode,
+ XGL_DBG_MSG_FILTER filter);
+ type_xglDbgSetMessageFilter real_xglDbgSetMessageFilter;
+ typedef XGL_RESULT( XGLAPI * type_xglDbgSetObjectTag)(
+ XGL_BASE_OBJECT object,
+ XGL_SIZE tagSize,
+ const XGL_VOID* pTag);
+ type_xglDbgSetObjectTag real_xglDbgSetObjectTag;
+ typedef XGL_RESULT( XGLAPI * type_xglDbgSetGlobalOption)(
+ XGL_DBG_GLOBAL_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData);
+ type_xglDbgSetGlobalOption real_xglDbgSetGlobalOption;
+ typedef XGL_RESULT( XGLAPI * type_xglDbgSetDeviceOption)(
+ XGL_DEVICE device,
+ XGL_DBG_DEVICE_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData);
+ type_xglDbgSetDeviceOption real_xglDbgSetDeviceOption;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDbgMarkerBegin)(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_CHAR* pMarker);
+ type_xglCmdDbgMarkerBegin real_xglCmdDbgMarkerBegin;
+ typedef XGL_VOID( XGLAPI * type_xglCmdDbgMarkerEnd)(
+ XGL_CMD_BUFFER cmdBuffer);
+ type_xglCmdDbgMarkerEnd real_xglCmdDbgMarkerEnd;
+
+ //WsiX11Ext entrypoints
+ typedef XGL_RESULT (XGLAPI * type_xglWsiX11AssociateConnection)(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo);
+ type_xglWsiX11AssociateConnection real_xglWsiX11AssociateConnection;
+ typedef XGL_RESULT (XGLAPI * type_xglWsiX11GetMSC)(
+ XGL_DEVICE device,
+ xcb_randr_crtc_t crtc,
+ XGL_UINT64* pMsc);
+ type_xglWsiX11GetMSC real_xglWsiX11GetMSC;
+ typedef XGL_RESULT (XGLAPI * type_xglWsiX11CreatePresentableImage)(
+ XGL_DEVICE device,
+ const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem);
+ type_xglWsiX11CreatePresentableImage real_xglWsiX11CreatePresentableImage;
+ typedef XGL_RESULT (XGLAPI * type_xglWsiX11QueuePresent)(
+ XGL_QUEUE queue,
+ const XGL_WSI_X11_PRESENT_INFO* pPresentInfo,
+ XGL_FENCE fence);
+ type_xglWsiX11QueuePresent real_xglWsiX11QueuePresent;
+};
+
+class xglReplay : public ApiReplay {
+public:
+ ~xglReplay();
+ xglReplay(unsigned int debugLevel);
+
+ int init(glv_replay::Display & disp);
+ xglDisplay * get_display() {return m_display;}
+ glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);
+ glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);
+private:
+ struct xglFuncs m_xglFuncs;
+ void copy_mem_remap_range_struct(XGL_VIRTUAL_MEMORY_REMAP_RANGE *outRange, const XGL_VIRTUAL_MEMORY_REMAP_RANGE *inRange);
+ unsigned int m_debugLevel;
+ xglDisplay *m_display;
+ XGL_MEMORY_HEAP_PROPERTIES m_heapProps[XGL_MAX_MEMORY_HEAPS];
+
+ std::map<XGL_GPU_MEMORY, XGLAllocInfo> m_mapData;
+ void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)
+ {
+ XGLAllocInfo info;
+ info.pData = NULL;
+ info.size = size;
+ m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));
+ }
+ void add_mapping_to_mapData(XGL_GPU_MEMORY handle, XGL_VOID *pData)
+ {
+ std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);
+ if (it == m_mapData.end())
+ {
+ glv_LogWarn("add_mapping_to_mapData() couldn't find entry\n");
+ return;
+ }
+
+ XGLAllocInfo &info = it->second;
+ if (info.pData != NULL)
+ {
+ glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\n");
+ }
+ info.pData = pData;
+ }
+ void rm_entry_from_mapData(XGL_GPU_MEMORY handle)
+ {
+ std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);
+ if (it == m_mapData.end())
+ return;
+ m_mapData.erase(it);
+ }
+ void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, XGL_VOID* pData)
+ {
+ std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);
+
+ if (it == m_mapData.end())
+ return;
+
+ XGLAllocInfo &info = it->second;
+
+ if (!pData || !info.pData)
+ {
+ glv_LogWarn("rm_mapping_from_mapData() null src or dest pointers\n");
+ info.pData = NULL;
+ return;
+ }
+ memcpy(info.pData, pData, info.size);
+ info.pData = NULL;
+ }
+
+ std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;
+ void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)
+ {
+ assert(pTraceGpu != NULL);
+ assert(pReplayGpu != NULL);
+ m_gpus[*pTraceGpu] = *pReplayGpu;
+ }
+
+ XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)
+ {
+ std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);
+ return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ void clear_all_map_handles()
+ {
+ m_gpus.clear();
+ m_devices.clear();
+ m_queues.clear();
+ m_memories.clear();
+ m_images.clear();
+ m_imageViews.clear();
+ m_colorTargetViews.clear();
+ m_depthStencilViews.clear();
+ m_shader.clear();
+ m_pipeline.clear();
+ m_pipelineDelta.clear();
+ m_sampler.clear();
+ m_descriptorSets.clear();
+ m_viewportStates.clear();
+ m_rasterStates.clear();
+ m_msaaStates.clear();
+ m_colorBlendStates.clear();
+ m_depthStencilStates.clear();
+ m_cmdBuffers.clear();
+ m_fences.clear();
+ m_queue_semaphores.clear();
+ m_events.clear();
+ m_queryPools.clear();
+ m_presentableImageSizes.clear();
+ }
+
+ std::map<XGL_DEVICE, XGL_DEVICE> m_devices;
+ void add_to_map(XGL_DEVICE* pTraceDevice, XGL_DEVICE* pReplayDevice)
+ {
+ assert(pTraceDevice != NULL);
+ assert(pReplayDevice != NULL);
+ m_devices[*pTraceDevice] = *pReplayDevice;
+ }
+ void rm_from_map(const XGL_DEVICE& deviceKey)
+ {
+ m_devices.erase(deviceKey);
+ }
+ XGL_DEVICE remap(const XGL_DEVICE& device)
+ {
+ std::map<XGL_DEVICE, XGL_DEVICE>::const_iterator q = m_devices.find(device);
+ return (q == m_devices.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_QUEUE, XGL_QUEUE> m_queues;
+ void add_to_map(XGL_QUEUE* pTraceQueue, XGL_QUEUE* pReplayQueue)
+ {
+ assert(pTraceQueue != NULL);
+ assert(pReplayQueue != NULL);
+ m_queues[*pTraceQueue] = *pReplayQueue;
+ }
+ // TODO how are queues individually removed from map???
+ XGL_QUEUE remap(const XGL_QUEUE& queue)
+ {
+ std::map<XGL_QUEUE, XGL_QUEUE>::const_iterator q = m_queues.find(queue);
+ return (q == m_queues.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY> m_memories;
+ void add_to_map(XGL_GPU_MEMORY* pTraceMemory, XGL_GPU_MEMORY* pReplayMemory)
+ {
+ assert(pTraceMemory != NULL);
+ assert(pReplayMemory != NULL);
+ m_memories[*pTraceMemory] = *pReplayMemory;
+ }
+ void rm_from_map(const XGL_GPU_MEMORY &gpuMemKey)
+ {
+ m_memories.erase(gpuMemKey);
+ }
+ XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& memory)
+ {
+ std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY>::const_iterator m = m_memories.find(memory);
+ return (m == m_memories.end()) ? XGL_NULL_HANDLE : m->second;
+ }
+
+ std::map<XGL_IMAGE, XGL_IMAGE> m_images;
+ void add_to_map(XGL_IMAGE* pTraceImage, XGL_IMAGE* pReplayImage)
+ {
+ assert(pTraceImage != NULL);
+ assert(pReplayImage != NULL);
+ m_images[*pTraceImage] = *pReplayImage;
+ }
+ void rm_from_map(const XGL_IMAGE& image)
+ {
+ m_images.erase(image);
+ }
+ XGL_IMAGE remap(const XGL_IMAGE& image)
+ {
+ std::map<XGL_IMAGE, XGL_IMAGE>::const_iterator q = m_images.find(image);
+ return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_IMAGE, XGL_EXTENT2D> m_presentableImageSizes;
+ void add_presentable_image_extents(const XGL_IMAGE* image, const XGL_EXTENT2D* extent)
+ {
+ assert(image != NULL);
+ assert(extent != NULL);
+ m_presentableImageSizes[*image] = *extent;
+ }
+
+ const XGL_EXTENT2D* get_presentable_image_extents(const XGL_IMAGE& image)
+ {
+ std::map<XGL_IMAGE, XGL_EXTENT2D>::const_iterator q = m_presentableImageSizes.find(image);
+ return (q == m_presentableImageSizes.end()) ? NULL : &(q->second);
+ }
+
+ std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW> m_imageViews;
+ void add_to_map(XGL_IMAGE_VIEW* pTraceImageView, XGL_IMAGE_VIEW* pReplayImageView)
+ {
+ assert(pTraceImageView != NULL);
+ assert(pReplayImageView != NULL);
+ m_imageViews[*pTraceImageView] = *pReplayImageView;
+ }
+ void rm_from_map(const XGL_IMAGE_VIEW& imageView)
+ {
+ m_imageViews.erase(imageView);
+ }
+ XGL_IMAGE_VIEW remap(const XGL_IMAGE_VIEW& imageView)
+ {
+ std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW>::const_iterator q = m_imageViews.find(imageView);
+ return (q == m_imageViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW> m_colorTargetViews;
+ void add_to_map(XGL_COLOR_ATTACHMENT_VIEW* pTraceColorTargetView, XGL_COLOR_ATTACHMENT_VIEW* pReplayColorTargetView)
+ {
+ assert(pTraceColorTargetView != NULL);
+ assert(pReplayColorTargetView != NULL);
+ m_colorTargetViews[*pTraceColorTargetView] = *pReplayColorTargetView;
+ }
+ void rm_from_map(const XGL_COLOR_ATTACHMENT_VIEW& colorTargetView)
+ {
+ m_colorTargetViews.erase(colorTargetView);
+ }
+ XGL_COLOR_ATTACHMENT_VIEW remap(const XGL_COLOR_ATTACHMENT_VIEW& colorTargetView)
+ {
+ std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW>::const_iterator q = m_colorTargetViews.find(colorTargetView);
+ return (q == m_colorTargetViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW> m_depthStencilViews;
+ void add_to_map(XGL_DEPTH_STENCIL_VIEW* pTraceDepthStencilView, XGL_DEPTH_STENCIL_VIEW* pReplayDepthStencilView)
+ {
+ assert(pTraceDepthStencilView != NULL);
+ assert(pReplayDepthStencilView != NULL);
+ m_depthStencilViews[*pTraceDepthStencilView] = *pReplayDepthStencilView;
+ }
+ void rm_from_map(const XGL_DEPTH_STENCIL_VIEW& depthStencilView)
+ {
+ m_depthStencilViews.erase(depthStencilView);
+ }
+ XGL_DEPTH_STENCIL_VIEW remap(const XGL_DEPTH_STENCIL_VIEW& depthStencilView)
+ {
+ std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW>::const_iterator q = m_depthStencilViews.find(depthStencilView);
+ return (q == m_depthStencilViews.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_SHADER, XGL_SHADER> m_shader;
+ void add_to_map(XGL_SHADER* pTraceShader, XGL_SHADER* pReplayShader)
+ {
+ assert(pTraceShader != NULL);
+ assert(pReplayShader != NULL);
+ m_shader[*pTraceShader] = *pReplayShader;
+ }
+ void rm_from_map(const XGL_SHADER& shader)
+ {
+ m_shader.erase(shader);
+ }
+ XGL_SHADER remap(const XGL_SHADER& shader)
+ {
+ std::map<XGL_SHADER, XGL_SHADER>::const_iterator q = m_shader.find(shader);
+ return (q == m_shader.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_PIPELINE, XGL_PIPELINE> m_pipeline;
+ void add_to_map(XGL_PIPELINE* pTracepipeline, XGL_PIPELINE* pReplaypipeline)
+ {
+ assert(pTracepipeline != NULL);
+ assert(pReplaypipeline != NULL);
+ m_pipeline[*pTracepipeline] = *pReplaypipeline;
+ }
+ void rm_from_map(const XGL_PIPELINE& pipeline)
+ {
+ m_pipeline.erase(pipeline);
+ }
+ XGL_PIPELINE remap(const XGL_PIPELINE& pipeline)
+ {
+ std::map<XGL_PIPELINE, XGL_PIPELINE>::const_iterator q = m_pipeline.find(pipeline);
+ return (q == m_pipeline.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA> m_pipelineDelta;
+ void add_to_map(XGL_PIPELINE_DELTA* pTracepipedelta, XGL_PIPELINE_DELTA* pReplaypipedelta)
+ {
+ assert(pTracepipedelta != NULL);
+ assert(pReplaypipedelta != NULL);
+ m_pipelineDelta[*pTracepipedelta] = *pReplaypipedelta;
+ }
+ void rm_from_map(const XGL_PIPELINE_DELTA& pipedelta)
+ {
+ m_pipelineDelta.erase(pipedelta);
+ }
+ XGL_PIPELINE_DELTA remap(const XGL_PIPELINE_DELTA& pipedelta)
+ {
+ std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA>::const_iterator q = m_pipelineDelta.find(pipedelta);
+ return (q == m_pipelineDelta.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_SAMPLER, XGL_SAMPLER> m_sampler;
+ void add_to_map(XGL_SAMPLER* pTracesampler, XGL_SAMPLER* pReplaysampler)
+ {
+ assert(pTracesampler != NULL);
+ assert(pReplaysampler != NULL);
+ m_sampler[*pTracesampler] = *pReplaysampler;
+ }
+ void rm_from_map(const XGL_SAMPLER& sampler)
+ {
+ m_sampler.erase(sampler);
+ }
+ XGL_SAMPLER remap(const XGL_SAMPLER& sampler)
+ {
+ std::map<XGL_SAMPLER, XGL_SAMPLER>::const_iterator q = m_sampler.find(sampler);
+ return (q == m_sampler.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET> m_descriptorSets;
+ void add_to_map(XGL_DESCRIPTOR_SET* pTraceSet, XGL_DESCRIPTOR_SET* pReplaySet)
+ {
+ assert(pTraceSet != NULL);
+ assert(pReplaySet != NULL);
+ m_descriptorSets[*pTraceSet] = *pReplaySet;
+ }
+ void rm_from_map(const XGL_DESCRIPTOR_SET& descriptorSet)
+ {
+ m_descriptorSets.erase(descriptorSet);
+ }
+ XGL_DESCRIPTOR_SET remap(const XGL_DESCRIPTOR_SET& descriptorSet)
+ {
+ std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET>::const_iterator q = m_descriptorSets.find(descriptorSet);
+ return (q == m_descriptorSets.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_VIEWPORT_STATE_OBJECT, XGL_VIEWPORT_STATE_OBJECT> m_viewportStates;
+ void add_to_map(XGL_VIEWPORT_STATE_OBJECT* pTraceState, XGL_VIEWPORT_STATE_OBJECT* pReplayState)
+ {
+ assert(pTraceState != NULL);
+ assert(pReplayState != NULL);
+ m_viewportStates[*pTraceState] = *pReplayState;
+ }
+ void rm_from_map(const XGL_VIEWPORT_STATE_OBJECT& state)
+ {
+ m_viewportStates.erase(state);
+ }
+ XGL_VIEWPORT_STATE_OBJECT remap(const XGL_VIEWPORT_STATE_OBJECT& state)
+ {
+ std::map<XGL_VIEWPORT_STATE_OBJECT, XGL_VIEWPORT_STATE_OBJECT>::const_iterator q = m_viewportStates.find(state);
+ return (q == m_viewportStates.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_RASTER_STATE_OBJECT, XGL_RASTER_STATE_OBJECT> m_rasterStates;
+ void add_to_map(XGL_RASTER_STATE_OBJECT* pTraceState, XGL_RASTER_STATE_OBJECT* pReplayState)
+ {
+ assert(pTraceState != NULL);
+ assert(pReplayState != NULL);
+ m_rasterStates[*pTraceState] = *pReplayState;
+ }
+ void rm_from_map(const XGL_RASTER_STATE_OBJECT& state)
+ {
+ m_rasterStates.erase(state);
+ }
+ XGL_RASTER_STATE_OBJECT remap(const XGL_RASTER_STATE_OBJECT& state)
+ {
+ std::map<XGL_RASTER_STATE_OBJECT, XGL_RASTER_STATE_OBJECT>::const_iterator q = m_rasterStates.find(state);
+ return (q == m_rasterStates.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_MSAA_STATE_OBJECT, XGL_MSAA_STATE_OBJECT> m_msaaStates;
+ void add_to_map(XGL_MSAA_STATE_OBJECT* pTraceState, XGL_MSAA_STATE_OBJECT* pReplayState)
+ {
+ assert(pTraceState != NULL);
+ assert(pReplayState != NULL);
+ m_msaaStates[*pTraceState] = *pReplayState;
+ }
+ void rm_from_map(const XGL_MSAA_STATE_OBJECT& state)
+ {
+ m_msaaStates.erase(state);
+ }
+ XGL_MSAA_STATE_OBJECT remap(const XGL_MSAA_STATE_OBJECT& state)
+ {
+ std::map<XGL_MSAA_STATE_OBJECT, XGL_MSAA_STATE_OBJECT>::const_iterator q = m_msaaStates.find(state);
+ return (q == m_msaaStates.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_COLOR_BLEND_STATE_OBJECT, XGL_COLOR_BLEND_STATE_OBJECT> m_colorBlendStates;
+ void add_to_map(XGL_COLOR_BLEND_STATE_OBJECT* pTraceState, XGL_COLOR_BLEND_STATE_OBJECT* pReplayState)
+ {
+ assert(pTraceState != NULL);
+ assert(pReplayState != NULL);
+ m_colorBlendStates[*pTraceState] = *pReplayState;
+ }
+ void rm_from_map(const XGL_COLOR_BLEND_STATE_OBJECT& state)
+ {
+ m_colorBlendStates.erase(state);
+ }
+ XGL_COLOR_BLEND_STATE_OBJECT remap(const XGL_COLOR_BLEND_STATE_OBJECT& state)
+ {
+ std::map<XGL_COLOR_BLEND_STATE_OBJECT, XGL_COLOR_BLEND_STATE_OBJECT>::const_iterator q = m_colorBlendStates.find(state);
+ return (q == m_colorBlendStates.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_DEPTH_STENCIL_STATE_OBJECT, XGL_DEPTH_STENCIL_STATE_OBJECT> m_depthStencilStates;
+ void add_to_map(XGL_DEPTH_STENCIL_STATE_OBJECT* pTraceState, XGL_DEPTH_STENCIL_STATE_OBJECT* pReplayState)
+ {
+ assert(pTraceState != NULL);
+ assert(pReplayState != NULL);
+ m_depthStencilStates[*pTraceState] = *pReplayState;
+ }
+ void rm_from_map(const XGL_DEPTH_STENCIL_STATE_OBJECT& state)
+ {
+ m_depthStencilStates.erase(state);
+ }
+ XGL_DEPTH_STENCIL_STATE_OBJECT remap(const XGL_DEPTH_STENCIL_STATE_OBJECT& state)
+ {
+ std::map<XGL_DEPTH_STENCIL_STATE_OBJECT, XGL_DEPTH_STENCIL_STATE_OBJECT>::const_iterator q = m_depthStencilStates.find(state);
+ return (q == m_depthStencilStates.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ XGL_STATE_OBJECT remap(const XGL_STATE_OBJECT& state)
+ {
+ /* includes: XGL_VIEWPORT_STATE_OBJECT, XGL_RASTER_STATE_OBJECT, XGL_MSAA_STATE_OBJECT
+ * XGL_COLOR_BLEND_STATE_OBJECT, XGL_DEPTH_STENCIL_STATE_OBJECT
+ */
+ XGL_STATE_OBJECT obj;
+ if ((obj = remap(static_cast <XGL_VIEWPORT_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_RASTER_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_MSAA_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_COLOR_BLEND_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DEPTH_STENCIL_STATE_OBJECT> (state))) != XGL_NULL_HANDLE)
+ return obj;
+ return XGL_NULL_HANDLE;
+ }
+ void rm_from_map(const XGL_STATE_OBJECT& state)
+ {
+ rm_from_map(static_cast <XGL_VIEWPORT_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_RASTER_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_MSAA_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_COLOR_BLEND_STATE_OBJECT> (state));
+ rm_from_map(static_cast <XGL_DEPTH_STENCIL_STATE_OBJECT> (state));
+ }
+ std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER> m_cmdBuffers;
+ void add_to_map(XGL_CMD_BUFFER* pTraceCmdBuffer, XGL_CMD_BUFFER* pReplayCmdBuffer)
+ {
+ assert(pTraceCmdBuffer != NULL);
+ assert(pReplayCmdBuffer != NULL);
+ m_cmdBuffers[*pTraceCmdBuffer] = *pReplayCmdBuffer;
+ }
+ void rm_from_map(const XGL_CMD_BUFFER& cmdBuffer)
+ {
+ m_cmdBuffers.erase(cmdBuffer);
+ }
+ XGL_CMD_BUFFER remap(const XGL_CMD_BUFFER& cmdBuffer)
+ {
+ std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER>::const_iterator q = m_cmdBuffers.find(cmdBuffer);
+ return (q == m_cmdBuffers.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_FENCE, XGL_FENCE> m_fences;
+ void add_to_map(XGL_FENCE* pTraceFence, XGL_FENCE* pReplayFence)
+ {
+ assert(pTraceFence != NULL);
+ assert(pReplayFence != NULL);
+ m_fences[*pTraceFence] = *pReplayFence;
+ }
+ void rm_from_map(const XGL_FENCE& fence)
+ {
+ m_fences.erase(fence);
+ }
+ XGL_FENCE remap(const XGL_FENCE& fence)
+ {
+ std::map<XGL_FENCE, XGL_FENCE>::const_iterator q = m_fences.find(fence);
+ return (q == m_fences.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE> m_queue_semaphores;
+ void add_to_map(XGL_QUEUE_SEMAPHORE* pTraceSema, XGL_QUEUE_SEMAPHORE* pReplaySema)
+ {
+ assert(pTraceSema != NULL);
+ assert(pReplaySema != NULL);
+ m_queue_semaphores[*pTraceSema] = *pReplaySema;
+ }
+ void rm_from_map(const XGL_QUEUE_SEMAPHORE& sema)
+ {
+ m_queue_semaphores.erase(sema);
+ }
+ XGL_QUEUE_SEMAPHORE remap(const XGL_QUEUE_SEMAPHORE& sema)
+ {
+ std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE>::const_iterator q = m_queue_semaphores.find(sema);
+ return (q == m_queue_semaphores.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_EVENT, XGL_EVENT> m_events;
+ void add_to_map(XGL_EVENT* pTraceEvent, XGL_EVENT* pReplayEvent)
+ {
+ assert(pTraceEvent != NULL);
+ assert(pReplayEvent != NULL);
+ m_events[*pTraceEvent] = *pReplayEvent;
+ }
+ void rm_from_map(const XGL_EVENT& event)
+ {
+ m_events.erase(event);
+ }
+ XGL_EVENT remap(const XGL_EVENT& event)
+ {
+ std::map<XGL_EVENT, XGL_EVENT>::const_iterator q = m_events.find(event);
+ return (q == m_events.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ std::map<XGL_QUERY_POOL, XGL_QUERY_POOL> m_queryPools;
+ void add_to_map(XGL_QUERY_POOL* pTracePool, XGL_QUERY_POOL* pReplayPool)
+ {
+ assert(pTracePool != NULL);
+ assert(pReplayPool != NULL);
+ m_queryPools[*pTracePool] = *pReplayPool;
+ }
+ void rm_from_map(const XGL_QUERY_POOL& queryPool)
+ {
+ m_queryPools.erase(queryPool);
+ }
+ XGL_QUERY_POOL remap(const XGL_QUERY_POOL& queryPool)
+ {
+ std::map<XGL_QUERY_POOL, XGL_QUERY_POOL>::const_iterator q = m_queryPools.find(queryPool);
+ return (q == m_queryPools.end()) ? XGL_NULL_HANDLE : q->second;
+ }
+
+ XGL_OBJECT remap(const XGL_OBJECT& object)
+ {
+ /*
+ * Includes: XGL_IMAGE, XGL_IMAGE_VIEW, XGL_COLOR_ATTACHMENT_VIEW, XGL_DEPTH_STENCIL_VIEW,
+ * XGL_SHADER, XGL_PIPELINE, XGL_PIPELINE_DELTA, XGL_SAMPLER, XGL_DESCRIPTOR_SET, XGL_STATE_OBJECT (plus subclasses),
+ * XGL_CMD_BUFFER, XGL_FENCE, XGL_QUEUE_SEMAPHORE, XGL_EVENT, XGL_QUERY_POOL
+ * XGL_WSI_WIN_DISPLAY
+ * XGL_BORDER_COLOR_PALETTE
+ */
+ XGL_OBJECT obj;
+ if ((obj = remap(static_cast <XGL_IMAGE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_IMAGE_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_COLOR_ATTACHMENT_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DEPTH_STENCIL_VIEW> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_SHADER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_PIPELINE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_PIPELINE_DELTA> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_SAMPLER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_DESCRIPTOR_SET> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_STATE_OBJECT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_CMD_BUFFER> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_FENCE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_QUEUE_SEMAPHORE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_EVENT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_QUERY_POOL> (object))) != XGL_NULL_HANDLE)
+ return obj;
+
+ return XGL_NULL_HANDLE;
+ }
+
+ void rm_from_map(const XGL_OBJECT & objKey)
+ {
+ rm_from_map(static_cast <XGL_IMAGE> (objKey));
+ rm_from_map(static_cast <XGL_IMAGE_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_COLOR_ATTACHMENT_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_DEPTH_STENCIL_VIEW> (objKey));
+ rm_from_map(static_cast <XGL_SHADER> (objKey));
+ rm_from_map(static_cast <XGL_PIPELINE> (objKey));
+ rm_from_map(static_cast <XGL_PIPELINE_DELTA> (objKey));
+ rm_from_map(static_cast <XGL_SAMPLER> (objKey));
+ rm_from_map(static_cast <XGL_DESCRIPTOR_SET> (objKey));
+ rm_from_map(static_cast <XGL_STATE_OBJECT> (objKey));
+ rm_from_map(static_cast <XGL_CMD_BUFFER> (objKey));
+ rm_from_map(static_cast <XGL_FENCE> (objKey));
+ rm_from_map(static_cast <XGL_QUEUE_SEMAPHORE> (objKey));
+ rm_from_map(static_cast <XGL_EVENT> (objKey));
+ rm_from_map(static_cast <XGL_QUERY_POOL> (objKey));
+ }
+
+ XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)
+ {
+ XGL_BASE_OBJECT obj;
+
+ /*
+ * Includes: XGL_DEVICE, XGL_QUEUE, XGL_GPU_MEMORY, XGL_OBJECT
+ */
+ if ((obj = remap(static_cast <XGL_DEVICE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_QUEUE> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_GPU_MEMORY> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ if ((obj = remap(static_cast <XGL_OBJECT> (object))) != XGL_NULL_HANDLE)
+ return obj;
+ return XGL_NULL_HANDLE;
+ }
+
+};
+
diff --git a/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt
new file mode 100644
index 0000000..e677727
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt
@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 2.8)
+
+# this project is only available on Windows
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+
+project(glvtrace_gl_fps)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glvtrace_gl_fps.c
+)
+
+set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
+
+include_directories(
+ ${SRC_DIR}
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/glvtrace
+ ${SRC_DIR}/thirdparty
+)
+
+add_library(${PROJECT_NAME} SHARED ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+ glvcommon
+ mhook
+)
+
+build_options_finalize()
+
+set_target_properties(glvtrace_gl_fps PROPERTIES LINKER_LANGUAGE C)
+
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
diff --git a/tools/glave/src/glv_extensions/glvtrace_gl_fps/glvtrace_gl_fps.c b/tools/glave/src/glv_extensions/glvtrace_gl_fps/glvtrace_gl_fps.c
new file mode 100644
index 0000000..e2fe1b7
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_gl_fps/glvtrace_gl_fps.c
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+
+// this tracer is really only valid on windows, so ifdef the entire file.
+#if defined(WIN32)
+
+#include <stdio.h>
+#include "glv_common.h"
+#include "glv_filelike.h"
+#include "glv_interconnect.h"
+#include "glv_trace_packet_identifiers.h"
+#include "mhook/mhook-lib/mhook.h"
+
+#pragma comment(lib, "opengl32.lib")
+
+// this is needed to be loaded by glvtrace
+GLVTRACER_EXPORT GLV_TRACER_ID GLVTRACER_STDCALL GLV_GetTracerId(void)
+{
+ return GLV_TID_GL_FPS;
+}
+
+// Pointers to real functions
+BOOL(APIENTRY * gReal_SwapBuffers)(HDC hdc) = SwapBuffers;
+
+BOOL g_bDisabled = FALSE;
+
+double g_frequency = 0.0;
+unsigned long long g_startTime = 0;
+unsigned long long g_frameCount = 0;
+
+BOOL APIENTRY hooked_SwapBuffers(HDC hdc)
+{
+ BOOL result = gReal_SwapBuffers(hdc);
+ unsigned long long difference;
+ double seconds;
+ LARGE_INTEGER tmp;
+ g_frameCount++;
+ QueryPerformanceCounter(&tmp);
+ difference = tmp.QuadPart - g_startTime;
+ seconds = (double)(difference) / g_frequency;
+ if (seconds > 1.0)
+ {
+ // it's been more than a second, report the frame rate
+ double frameRate = (double)(g_frameCount) / seconds;
+ glv_LogInfo("FPS: %f", frameRate);
+
+ // update start time and reset frame count
+ g_startTime = tmp.QuadPart;
+ g_frameCount = 0;
+ }
+
+ return result;
+}
+void AttachHooks()
+{
+ BOOL hookSuccess;
+ // If you need to debug startup, build with this set to true, then attach and change it to false.
+#ifdef _DEBUG
+ BOOL debugStartup = FALSE;
+ while (debugStartup);
+#endif
+
+ Mhook_Initialize();
+ Mhook_BeginMultiOperation(FALSE);
+ hookSuccess = TRUE;
+ if (gReal_SwapBuffers != NULL)
+ {
+ hookSuccess = Mhook_SetHook((PVOID*)&gReal_SwapBuffers, hooked_SwapBuffers);
+ }
+
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook SwapBuffers.\n");
+ }
+
+ Mhook_EndMultiOperation();
+}
+
+GLVTRACER_EXIT TrapExit(void)
+{
+ int i = 0;
+ ++i;
+}
+
+void DetachHooks()
+{
+ BOOL unhookSuccess = TRUE;
+ if (gReal_SwapBuffers != NULL)
+ {
+ unhookSuccess = Mhook_Unhook((PVOID*)&gReal_SwapBuffers);
+ }
+
+ if (!unhookSuccess)
+ {
+ glv_LogError("Failed to unhook SwapBuffers.\n");
+ }
+}
+
+BOOL APIENTRY DllMain( HMODULE hModule,
+ DWORD ul_reason_for_call,
+ LPVOID lpReserved
+ )
+{
+ char exePath[MAX_PATH];
+ char* substr = ((sizeof(void*) == 4)? "glvtrace32.exe" : "glvtrace64.exe");
+ GetModuleFileName(NULL, exePath, MAX_PATH);
+ hModule;
+ lpReserved;
+
+ // only do the hooking and networking if the tracer is NOT being loaded by glvtrace
+ if (strstr(exePath, substr) == NULL)
+ {
+ switch (ul_reason_for_call)
+ {
+ case DLL_PROCESS_ATTACH:
+ {
+ LARGE_INTEGER tmp;
+ gMessageStream = glv_MessageStream_create(TRUE, "", GLV_BASE_PORT + GLV_TID_GL_FPS);
+
+ glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));
+ glv_tracelog_set_tracer_id(GLV_TID_GL_FPS);
+
+ glv_LogInfo("glvtrace_gl_fps loaded.");
+ if (QueryPerformanceFrequency(&tmp) == FALSE)
+ {
+ glv_LogError("QueryPerformanceFrequency failed, disabling tracer.");
+ g_bDisabled = TRUE;
+ }
+ else
+ {
+ g_frequency = (double)tmp.QuadPart;
+
+ QueryPerformanceCounter(&tmp);
+ g_startTime = tmp.QuadPart;
+
+ atexit(TrapExit);
+ AttachHooks();
+ }
+
+ break;
+ }
+ case DLL_PROCESS_DETACH:
+ {
+ if (!g_bDisabled)
+ {
+ DetachHooks();
+ }
+
+ GLV_DELETE(glv_trace_get_trace_file());
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ return TRUE;
+}
+#endif
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
new file mode 100644
index 0000000..a79b8be
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
@@ -0,0 +1,61 @@
+cmake_minimum_required(VERSION 2.8)
+
+# this project is currently only available on Linux
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+
+project(glvtrace_xgl)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/thirdparty/xgl/inc/)
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glvtrace_xgl.c
+ glvtrace_xgl_xgl.c
+ glvtrace_xgl_xgldbg.c
+ glvtrace_xgl_xglwsix11ext.c
+)
+
+set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
+
+set (HDR_LIST
+ glvtrace_xgl_packet_id.h
+ glvtrace_xgl_xgl.h
+ glvtrace_xgl_xgl_structs.h
+ glvtrace_xgl_xgldbg.h
+ glvtrace_xgl_xgldbg_structs.h
+ glvtrace_xgl_xglwsix11ext.h
+ glvtrace_xgl_xglwsix11ext_structs.h
+)
+
+include_directories(
+ ${SRC_DIR}
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/glvtrace
+ ${SRC_DIR}/thirdparty
+)
+
+add_library(${PROJECT_NAME} SHARED ${SRC_LIST} ${HDR_LIST})
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+target_link_libraries(${PROJECT_NAME}
+ glvcommon
+ ${SRC_DIR}/thirdparty/xgl/lib/libXGL.so.0
+ -shared
+ -ldl
+)
+endif()
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+target_link_libraries(${PROJECT_NAME}
+ glvcommon
+ ${SRC_DIR}/thirdparty/xgl/lib/libXGL.dll
+)
+endif()
+
+build_options_finalize()
+
+set_target_properties(glvtrace_xgl PROPERTIES LINKER_LANGUAGE C)
+
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl.c b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl.c
new file mode 100644
index 0000000..0ba122c
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2014, Lunarg, Inc. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 "glv_common.h"
+#include "glv_filelike.h"
+#include "glv_interconnect.h"
+#include "glvtrace_xgl_xgl.h"
+#include "glvtrace_xgl_xgldbg.h"
+#include "glvtrace_xgl_xglwsix11ext.h"
+
+// this is needed to be loaded by glvtrace
+GLVTRACER_EXPORT GLV_TRACER_ID GLVTRACER_STDCALL GLV_GetTracerId(void)
+{
+ return GLV_TID_XGL;
+}
+
+GLVTRACER_EXIT TrapExit(void)
+{
+ int i = 0;
+ ++i;
+}
+
+extern
+GLVTRACER_ENTRY _Load(void)
+{
+ // only do the hooking and networking if the tracer is NOT loaded by glvtrace
+ if (glv_is_loaded_into_glvtrace() == FALSE)
+ {
+ gMessageStream = glv_MessageStream_create(TRUE, "", GLV_BASE_PORT + GLV_TID_XGL);
+// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));
+ glv_tracelog_set_tracer_id(GLV_TID_XGL);
+ glv_LogInfo("glvtrace_xgl loaded into PID %d\n", glv_get_pid());
+ atexit(TrapExit);
+
+ // If you need to debug startup, build with this set to true, then attach and change it to false.
+ #ifdef _DEBUG
+ {
+ BOOL debugStartup = FALSE;
+ while (debugStartup);
+ }
+ #endif
+#ifndef PLATFORM_LINUX
+ AttachHooks();
+ AttachHooks_xgldbg();
+ AttachHooks_xglwsix11ext();
+#endif
+ }
+}
+
+GLVTRACER_LEAVE _Unload(void)
+{
+ // only do the hooking and networking if the tracer is NOT loaded by glvtrace
+ if (glv_is_loaded_into_glvtrace() == FALSE)
+ {
+ DetachHooks();
+ DetachHooks_xgldbg();
+ DetachHooks_xglwsix11ext();
+
+ glv_trace_packet_header* pHeader = glv_create_trace_packet(GLV_GetTracerId(), GLV_TPI_MARKER_TERMINATE_PROCESS, 0, 0);
+ glv_finalize_trace_packet(pHeader);
+ FileLike* pFileLike = glv_FileLike_create_msg(gMessageStream);
+ glv_write_trace_packet(pHeader, pFileLike);
+ glv_delete_trace_packet(&pHeader);
+ glv_free(pFileLike);
+
+ if (gMessageStream)
+ glv_MessageStream_destroy(&gMessageStream);
+
+ }
+ glv_tracelog_delete_log_file();
+}
+
+#if defined(WIN32)
+BOOL APIENTRY DllMain( HMODULE hModule,
+ DWORD ul_reason_for_call,
+ LPVOID lpReserved
+ )
+{
+ hModule;
+ lpReserved;
+
+ switch (ul_reason_for_call)
+ {
+ case DLL_PROCESS_ATTACH:
+ {
+ _Load();
+ break;
+ }
+ case DLL_PROCESS_DETACH:
+ {
+ _Unload();
+ break;
+ }
+ default:
+ break;
+ }
+ return TRUE;
+}
+#endif
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_packet_id.h
new file mode 100644
index 0000000..b2c7010
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_packet_id.h
@@ -0,0 +1,175 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+#include "glv_trace_packet_utils.h"
+#include "glv_interconnect.h"
+
+#define SEND_ENTRYPOINT_ID(entrypoint) \
+ FileLike* pFile; \
+ pFile = glv_FileLike_create_msg(gMessageStream); \
+ glv_trace_set_trace_file(pFile); \
+ glv_TraceInfo(#entrypoint "\n");
+
+#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) \
+ FileLike* pFile; \
+ pFile = glv_FileLike_create_msg(gMessageStream); \
+ glv_trace_set_trace_file(pFile); \
+ glv_TraceInfo(entrypoint, __VA_ARGS__);
+
+#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \
+ pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);
+
+#define FINISH_TRACE_PACKET() \
+ glv_finalize_trace_packet(pHeader); \
+ glv_write_trace_packet(pHeader, pFile); \
+ glv_delete_trace_packet(&pHeader); \
+ GLV_DELETE(pFile);
+
+enum GLV_TRACE_PACKET_ID_XGL
+{
+ // xgl.h
+ GLV_TPI_XGL_xglInitAndEnumerateGpus = GLV_TPI_BEGIN_API_HERE,
+ GLV_TPI_XGL_xglGetGpuInfo,
+ GLV_TPI_XGL_xglCreateDevice,
+ GLV_TPI_XGL_xglDestroyDevice,
+ GLV_TPI_XGL_xglGetExtensionSupport,
+ GLV_TPI_XGL_xglGetDeviceQueue,
+ GLV_TPI_XGL_xglQueueSubmit,
+ GLV_TPI_XGL_xglQueueSetGlobalMemReferences,
+ GLV_TPI_XGL_xglQueueWaitIdle,
+ GLV_TPI_XGL_xglDeviceWaitIdle,
+ GLV_TPI_XGL_xglGetMemoryHeapCount,
+ GLV_TPI_XGL_xglGetMemoryHeapInfo,
+ GLV_TPI_XGL_xglAllocMemory,
+ GLV_TPI_XGL_xglFreeMemory,
+ GLV_TPI_XGL_xglSetMemoryPriority,
+ GLV_TPI_XGL_xglMapMemory,
+ GLV_TPI_XGL_xglUnmapMemory,
+ GLV_TPI_XGL_xglPinSystemMemory,
+ GLV_TPI_XGL_xglRemapVirtualMemoryPages,
+ GLV_TPI_XGL_xglGetMultiGpuCompatibility,
+ GLV_TPI_XGL_xglOpenSharedMemory,
+ GLV_TPI_XGL_xglOpenSharedQueueSemaphore,
+ GLV_TPI_XGL_xglOpenPeerMemory,
+ GLV_TPI_XGL_xglOpenPeerImage,
+ GLV_TPI_XGL_xglDestroyObject,
+ GLV_TPI_XGL_xglGetObjectInfo,
+ GLV_TPI_XGL_xglBindObjectMemory,
+ GLV_TPI_XGL_xglCreateFence,
+ GLV_TPI_XGL_xglGetFenceStatus,
+ GLV_TPI_XGL_xglWaitForFences,
+ GLV_TPI_XGL_xglCreateQueueSemaphore,
+ GLV_TPI_XGL_xglSignalQueueSemaphore,
+ GLV_TPI_XGL_xglWaitQueueSemaphore,
+ GLV_TPI_XGL_xglCreateEvent,
+ GLV_TPI_XGL_xglGetEventStatus,
+ GLV_TPI_XGL_xglSetEvent,
+ GLV_TPI_XGL_xglResetEvent,
+ GLV_TPI_XGL_xglCreateQueryPool,
+ GLV_TPI_XGL_xglGetQueryPoolResults,
+ GLV_TPI_XGL_xglGetFormatInfo,
+ GLV_TPI_XGL_xglCreateImage,
+ GLV_TPI_XGL_xglGetImageSubresourceInfo,
+ GLV_TPI_XGL_xglCreateImageView,
+ GLV_TPI_XGL_xglCreateColorAttachmentView,
+ GLV_TPI_XGL_xglCreateDepthStencilView,
+ GLV_TPI_XGL_xglCreateShader,
+ GLV_TPI_XGL_xglCreateGraphicsPipeline,
+ GLV_TPI_XGL_xglCreateComputePipeline,
+ GLV_TPI_XGL_xglStorePipeline,
+ GLV_TPI_XGL_xglLoadPipeline,
+ GLV_TPI_XGL_xglCreatePipelineDelta,
+ GLV_TPI_XGL_xglCreateSampler,
+ GLV_TPI_XGL_xglCreateDescriptorSet,
+ GLV_TPI_XGL_xglBeginDescriptorSetUpdate,
+ GLV_TPI_XGL_xglEndDescriptorSetUpdate,
+ GLV_TPI_XGL_xglAttachSamplerDescriptors,
+ GLV_TPI_XGL_xglAttachImageViewDescriptors,
+ GLV_TPI_XGL_xglAttachMemoryViewDescriptors,
+ GLV_TPI_XGL_xglAttachNestedDescriptors,
+ GLV_TPI_XGL_xglClearDescriptorSetSlots,
+ GLV_TPI_XGL_xglCreateViewportState,
+ GLV_TPI_XGL_xglCreateRasterState,
+ GLV_TPI_XGL_xglCreateMsaaState,
+ GLV_TPI_XGL_xglCreateColorBlendState,
+ GLV_TPI_XGL_xglCreateDepthStencilState,
+ GLV_TPI_XGL_xglCreateCommandBuffer,
+ GLV_TPI_XGL_xglBeginCommandBuffer,
+ GLV_TPI_XGL_xglEndCommandBuffer,
+ GLV_TPI_XGL_xglResetCommandBuffer,
+ GLV_TPI_XGL_xglCmdBindPipeline,
+ GLV_TPI_XGL_xglCmdBindPipelineDelta,
+ GLV_TPI_XGL_xglCmdBindStateObject,
+ GLV_TPI_XGL_xglCmdBindDescriptorSet,
+ GLV_TPI_XGL_xglCmdBindDynamicMemoryView,
+ GLV_TPI_XGL_xglCmdBindIndexData,
+ GLV_TPI_XGL_xglCmdBindAttachments,
+ GLV_TPI_XGL_xglCmdPrepareMemoryRegions,
+ GLV_TPI_XGL_xglCmdPrepareImages,
+ GLV_TPI_XGL_xglCmdDraw,
+ GLV_TPI_XGL_xglCmdDrawIndexed,
+ GLV_TPI_XGL_xglCmdDrawIndirect,
+ GLV_TPI_XGL_xglCmdDrawIndexedIndirect,
+ GLV_TPI_XGL_xglCmdDispatch,
+ GLV_TPI_XGL_xglCmdDispatchIndirect,
+ GLV_TPI_XGL_xglCmdCopyMemory,
+ GLV_TPI_XGL_xglCmdCopyImage,
+ GLV_TPI_XGL_xglCmdCopyMemoryToImage,
+ GLV_TPI_XGL_xglCmdCopyImageToMemory,
+ GLV_TPI_XGL_xglCmdCloneImageData,
+ GLV_TPI_XGL_xglCmdUpdateMemory,
+ GLV_TPI_XGL_xglCmdFillMemory,
+ GLV_TPI_XGL_xglCmdClearColorImage,
+ GLV_TPI_XGL_xglCmdClearColorImageRaw,
+ GLV_TPI_XGL_xglCmdClearDepthStencil,
+ GLV_TPI_XGL_xglCmdResolveImage,
+ GLV_TPI_XGL_xglCmdSetEvent,
+ GLV_TPI_XGL_xglCmdResetEvent,
+ GLV_TPI_XGL_xglCmdMemoryAtomic,
+ GLV_TPI_XGL_xglCmdBeginQuery,
+ GLV_TPI_XGL_xglCmdEndQuery,
+ GLV_TPI_XGL_xglCmdResetQueryPool,
+ GLV_TPI_XGL_xglCmdWriteTimestamp,
+ GLV_TPI_XGL_xglCmdInitAtomicCounters,
+ GLV_TPI_XGL_xglCmdLoadAtomicCounters,
+ GLV_TPI_XGL_xglCmdSaveAtomicCounters,
+
+ // xglDbg.h
+ GLV_TPI_XGL_xglDbgSetValidationLevel,
+ GLV_TPI_XGL_xglDbgRegisterMsgCallback,
+ GLV_TPI_XGL_xglDbgUnregisterMsgCallback,
+ GLV_TPI_XGL_xglDbgSetMessageFilter,
+ GLV_TPI_XGL_xglDbgSetObjectTag,
+ GLV_TPI_XGL_xglDbgSetGlobalOption,
+ GLV_TPI_XGL_xglDbgSetDeviceOption,
+ GLV_TPI_XGL_xglCmdDbgMarkerBegin,
+ GLV_TPI_XGL_xglCmdDbgMarkerEnd,
+
+ //xglWsiX11Ext.h
+ GLV_TPI_XGL_xglWsiX11AssociateConnection,
+ GLV_TPI_XGL_xglWsiX11GetMSC,
+ GLV_TPI_XGL_xglWsiX11CreatePresentableImage,
+ GLV_TPI_XGL_xglWsiX11QueuePresent,
+};
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl.c b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl.c
new file mode 100644
index 0000000..c885b42
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl.c
@@ -0,0 +1,3575 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glv_platform.h"
+#include "glv_common.h"
+#include "glvtrace_xgl_xgl.h"
+#include "glvtrace_xgl_xgldbg.h"
+#include "glvtrace_xgl_xglwsix11ext.h"
+#include "glv_interconnect.h"
+#include "glv_filelike.h"
+#ifdef WIN32
+#include "mhook/mhook-lib/mhook.h"
+#endif
+#include "glv_trace_packet_utils.h"
+#include <stdio.h>
+
+
+static XGL_RESULT( XGLAPI * real_xglInitAndEnumerateGpus)(
+ const XGL_APPLICATION_INFO* pAppInfo,
+ const XGL_ALLOC_CALLBACKS* pAllocCb,
+ XGL_UINT maxGpus,
+ XGL_UINT* pGpuCount,
+ XGL_PHYSICAL_GPU* pGpus) = xglInitAndEnumerateGpus;
+
+static XGL_RESULT( XGLAPI * real_xglGetGpuInfo)(
+ XGL_PHYSICAL_GPU gpu,
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglGetGpuInfo;
+
+static XGL_RESULT( XGLAPI * real_xglCreateDevice)(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo,
+ XGL_DEVICE* pDevice) = xglCreateDevice;
+
+static XGL_RESULT( XGLAPI * real_xglDestroyDevice)(
+ XGL_DEVICE device) = xglDestroyDevice;
+
+static XGL_RESULT( XGLAPI * real_xglGetExtensionSupport)(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_CHAR* pExtName) = xglGetExtensionSupport;
+
+static XGL_RESULT( XGLAPI * real_xglGetDeviceQueue)(
+ XGL_DEVICE device,
+ XGL_QUEUE_TYPE queueType,
+ XGL_UINT queueIndex,
+ XGL_QUEUE* pQueue) = xglGetDeviceQueue;
+
+static XGL_RESULT( XGLAPI * real_xglQueueSubmit)(
+ XGL_QUEUE queue,
+ XGL_UINT cmdBufferCount,
+ const XGL_CMD_BUFFER* pCmdBuffers,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs,
+ XGL_FENCE fence) = xglQueueSubmit;
+
+static XGL_RESULT( XGLAPI * real_xglQueueSetGlobalMemReferences)(
+ XGL_QUEUE queue,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs) = xglQueueSetGlobalMemReferences;
+
+static XGL_RESULT( XGLAPI * real_xglQueueWaitIdle)(
+ XGL_QUEUE queue) = xglQueueWaitIdle;
+
+static XGL_RESULT( XGLAPI * real_xglDeviceWaitIdle)(
+ XGL_DEVICE device) = xglDeviceWaitIdle;
+
+static XGL_RESULT( XGLAPI * real_xglGetMemoryHeapCount)(
+ XGL_DEVICE device,
+ XGL_UINT* pCount) = xglGetMemoryHeapCount;
+
+static XGL_RESULT( XGLAPI * real_xglGetMemoryHeapInfo)(
+ XGL_DEVICE device,
+ XGL_UINT heapId,
+ XGL_MEMORY_HEAP_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglGetMemoryHeapInfo;
+
+static XGL_RESULT( XGLAPI * real_xglAllocMemory)(
+ XGL_DEVICE device,
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
+ XGL_GPU_MEMORY* pMem) = xglAllocMemory;
+
+static XGL_RESULT( XGLAPI * real_xglFreeMemory)(
+ XGL_GPU_MEMORY mem) = xglFreeMemory;
+
+static XGL_RESULT( XGLAPI * real_xglSetMemoryPriority)(
+ XGL_GPU_MEMORY mem,
+ XGL_MEMORY_PRIORITY priority) = xglSetMemoryPriority;
+
+static XGL_RESULT( XGLAPI * real_xglMapMemory)(
+ XGL_GPU_MEMORY mem,
+ XGL_FLAGS flags, // Reserved
+ XGL_VOID** ppData) = xglMapMemory;
+
+static XGL_RESULT( XGLAPI * real_xglUnmapMemory)(
+ XGL_GPU_MEMORY mem) = xglUnmapMemory;
+
+static XGL_RESULT( XGLAPI * real_xglPinSystemMemory)(
+ XGL_DEVICE device,
+ const XGL_VOID* pSysMem,
+ XGL_SIZE memSize,
+ XGL_GPU_MEMORY* pMem) = xglPinSystemMemory;
+
+static XGL_RESULT( XGLAPI * real_xglRemapVirtualMemoryPages)(
+ XGL_DEVICE device,
+ XGL_UINT rangeCount,
+ const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
+ XGL_UINT preWaitSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
+ XGL_UINT postSignalSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores) = xglRemapVirtualMemoryPages;
+
+static XGL_RESULT( XGLAPI * real_xglGetMultiGpuCompatibility)(
+ XGL_PHYSICAL_GPU gpu0,
+ XGL_PHYSICAL_GPU gpu1,
+ XGL_GPU_COMPATIBILITY_INFO* pInfo) = xglGetMultiGpuCompatibility;
+
+static XGL_RESULT( XGLAPI * real_xglOpenSharedMemory)(
+ XGL_DEVICE device,
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem) = xglOpenSharedMemory;
+
+static XGL_RESULT( XGLAPI * real_xglOpenSharedQueueSemaphore)(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore) = xglOpenSharedQueueSemaphore;
+
+static XGL_RESULT( XGLAPI * real_xglOpenPeerMemory)(
+ XGL_DEVICE device,
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem) = xglOpenPeerMemory;
+
+static XGL_RESULT( XGLAPI * real_xglOpenPeerImage)(
+ XGL_DEVICE device,
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem) = xglOpenPeerImage;
+
+static XGL_RESULT( XGLAPI * real_xglDestroyObject)(
+ XGL_OBJECT object) = xglDestroyObject;
+
+static XGL_RESULT( XGLAPI * real_xglGetObjectInfo)(
+ XGL_BASE_OBJECT object,
+ XGL_OBJECT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglGetObjectInfo;
+
+static XGL_RESULT( XGLAPI * real_xglBindObjectMemory)(
+ XGL_OBJECT object,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset) = xglBindObjectMemory;
+
+static XGL_RESULT( XGLAPI * real_xglCreateFence)(
+ XGL_DEVICE device,
+ const XGL_FENCE_CREATE_INFO* pCreateInfo,
+ XGL_FENCE* pFence) = xglCreateFence;
+
+static XGL_RESULT( XGLAPI * real_xglGetFenceStatus)(
+ XGL_FENCE fence) = xglGetFenceStatus;
+
+static XGL_RESULT( XGLAPI * real_xglWaitForFences)(
+ XGL_DEVICE device,
+ XGL_UINT fenceCount,
+ const XGL_FENCE* pFences,
+ XGL_BOOL waitAll,
+ XGL_UINT64 timeout) = xglWaitForFences;
+
+static XGL_RESULT( XGLAPI * real_xglCreateQueueSemaphore)(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore) = xglCreateQueueSemaphore;
+
+static XGL_RESULT( XGLAPI * real_xglSignalQueueSemaphore)(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore) = xglSignalQueueSemaphore;
+
+static XGL_RESULT( XGLAPI * real_xglWaitQueueSemaphore)(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore) = xglWaitQueueSemaphore;
+
+static XGL_RESULT( XGLAPI * real_xglCreateEvent)(
+ XGL_DEVICE device,
+ const XGL_EVENT_CREATE_INFO* pCreateInfo,
+ XGL_EVENT* pEvent) = xglCreateEvent;
+
+static XGL_RESULT( XGLAPI * real_xglGetEventStatus)(
+ XGL_EVENT event) = xglGetEventStatus;
+
+static XGL_RESULT( XGLAPI * real_xglSetEvent)(
+ XGL_EVENT event) = xglSetEvent;
+
+static XGL_RESULT( XGLAPI * real_xglResetEvent)(
+ XGL_EVENT event) = xglResetEvent;
+
+static XGL_RESULT( XGLAPI * real_xglCreateQueryPool)(
+ XGL_DEVICE device,
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ XGL_QUERY_POOL* pQueryPool) = xglCreateQueryPool;
+
+static XGL_RESULT( XGLAPI * real_xglGetQueryPoolResults)(
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglGetQueryPoolResults;
+
+static XGL_RESULT( XGLAPI * real_xglGetFormatInfo)(
+ XGL_DEVICE device,
+ XGL_FORMAT format,
+ XGL_FORMAT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglGetFormatInfo;
+
+static XGL_RESULT( XGLAPI * real_xglCreateImage)(
+ XGL_DEVICE device,
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage) = xglCreateImage;
+
+static XGL_RESULT( XGLAPI * real_xglGetImageSubresourceInfo)(
+ XGL_IMAGE image,
+ const XGL_IMAGE_SUBRESOURCE* pSubresource,
+ XGL_SUBRESOURCE_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglGetImageSubresourceInfo;
+
+static XGL_RESULT( XGLAPI * real_xglCreateImageView)(
+ XGL_DEVICE device,
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE_VIEW* pView) = xglCreateImageView;
+
+static XGL_RESULT( XGLAPI * real_xglCreateColorAttachmentView)(
+ XGL_DEVICE device,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_ATTACHMENT_VIEW* pView) = xglCreateColorAttachmentView;
+
+static XGL_RESULT( XGLAPI * real_xglCreateDepthStencilView)(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_VIEW* pView) = xglCreateDepthStencilView;
+
+static XGL_RESULT( XGLAPI * real_xglCreateShader)(
+ XGL_DEVICE device,
+ const XGL_SHADER_CREATE_INFO* pCreateInfo,
+ XGL_SHADER* pShader) = xglCreateShader;
+
+static XGL_RESULT( XGLAPI * real_xglCreateGraphicsPipeline)(
+ XGL_DEVICE device,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline) = xglCreateGraphicsPipeline;
+
+static XGL_RESULT( XGLAPI * real_xglCreateComputePipeline)(
+ XGL_DEVICE device,
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline) = xglCreateComputePipeline;
+
+static XGL_RESULT( XGLAPI * real_xglStorePipeline)(
+ XGL_PIPELINE pipeline,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData) = xglStorePipeline;
+
+static XGL_RESULT( XGLAPI * real_xglLoadPipeline)(
+ XGL_DEVICE device,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData,
+ XGL_PIPELINE* pPipeline) = xglLoadPipeline;
+
+static XGL_RESULT( XGLAPI * real_xglCreatePipelineDelta)(
+ XGL_DEVICE device,
+ XGL_PIPELINE p1,
+ XGL_PIPELINE p2,
+ XGL_PIPELINE_DELTA* delta) = xglCreatePipelineDelta;
+
+static XGL_RESULT( XGLAPI * real_xglCreateSampler)(
+ XGL_DEVICE device,
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
+ XGL_SAMPLER* pSampler) = xglCreateSampler;
+
+static XGL_RESULT( XGLAPI * real_xglCreateDescriptorSet)(
+ XGL_DEVICE device,
+ const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_SET* pDescriptorSet) = xglCreateDescriptorSet;
+
+
+static XGL_VOID( XGLAPI * real_xglBeginDescriptorSetUpdate)(
+ XGL_DESCRIPTOR_SET descriptorSet) = xglBeginDescriptorSetUpdate;
+
+static XGL_VOID( XGLAPI * real_xglEndDescriptorSetUpdate)(
+ XGL_DESCRIPTOR_SET descriptorSet) = xglEndDescriptorSetUpdate;
+
+static XGL_VOID( XGLAPI * real_xglAttachSamplerDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_SAMPLER* pSamplers) = xglAttachSamplerDescriptors;
+
+static XGL_VOID( XGLAPI * real_xglAttachImageViewDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews) = xglAttachImageViewDescriptors;
+
+static XGL_VOID( XGLAPI * real_xglAttachMemoryViewDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews) = xglAttachMemoryViewDescriptors;
+
+static XGL_VOID( XGLAPI * real_xglAttachNestedDescriptors)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets) = xglAttachNestedDescriptors;
+
+static XGL_VOID( XGLAPI * real_xglClearDescriptorSetSlots)(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount) = xglClearDescriptorSetSlots;
+
+static XGL_RESULT( XGLAPI * real_xglCreateViewportState)(
+ XGL_DEVICE device,
+ const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
+ XGL_VIEWPORT_STATE_OBJECT* pState) = xglCreateViewportState;
+
+static XGL_RESULT( XGLAPI * real_xglCreateRasterState)(
+ XGL_DEVICE device,
+ const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
+ XGL_RASTER_STATE_OBJECT* pState) = xglCreateRasterState;
+
+static XGL_RESULT( XGLAPI * real_xglCreateMsaaState)(
+ XGL_DEVICE device,
+ const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
+ XGL_MSAA_STATE_OBJECT* pState) = xglCreateMsaaState;
+
+static XGL_RESULT( XGLAPI * real_xglCreateColorBlendState)(
+ XGL_DEVICE device,
+ const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_BLEND_STATE_OBJECT* pState) = xglCreateColorBlendState;
+
+static XGL_RESULT( XGLAPI * real_xglCreateDepthStencilState)(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_STATE_OBJECT* pState) = xglCreateDepthStencilState;
+
+static XGL_RESULT( XGLAPI * real_xglCreateCommandBuffer)(
+ XGL_DEVICE device,
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_CMD_BUFFER* pCmdBuffer) = xglCreateCommandBuffer;
+
+static XGL_RESULT( XGLAPI * real_xglBeginCommandBuffer)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_FLAGS flags) = xglBeginCommandBuffer; // XGL_CMD_BUFFER_BUILD_FLAGS
+
+static XGL_RESULT( XGLAPI * real_xglEndCommandBuffer)(
+ XGL_CMD_BUFFER cmdBuffer) = xglEndCommandBuffer;
+
+static XGL_RESULT( XGLAPI * real_xglResetCommandBuffer)(
+ XGL_CMD_BUFFER cmdBuffer) = xglResetCommandBuffer;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindPipeline)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE pipeline) = xglCmdBindPipeline;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindPipelineDelta)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE_DELTA delta) = xglCmdBindPipelineDelta;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindStateObject)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_STATE_BIND_POINT stateBindPoint,
+ XGL_STATE_OBJECT state) = xglCmdBindStateObject;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindDescriptorSet)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT index,
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT slotOffset) = xglCmdBindDescriptorSet;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindDynamicMemoryView)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView) = xglCmdBindDynamicMemoryView;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindIndexData)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_INDEX_TYPE indexType) = xglCmdBindIndexData;
+
+static XGL_VOID( XGLAPI * real_xglCmdBindAttachments)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT colorTargetCount,
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorTargets,
+ const XGL_DEPTH_STENCIL_BIND_INFO* pDepthTarget) = xglCmdBindAttachments;
+
+static XGL_VOID( XGLAPI * real_xglCmdPrepareMemoryRegions)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_MEMORY_STATE_TRANSITION* pStateTransitions) = xglCmdPrepareMemoryRegions;
+
+static XGL_VOID( XGLAPI * real_xglCmdPrepareImages)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_IMAGE_STATE_TRANSITION* pStateTransitions) = xglCmdPrepareImages;
+
+static XGL_VOID( XGLAPI * real_xglCmdDraw)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstVertex,
+ XGL_UINT vertexCount,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount) = xglCmdDraw;
+
+static XGL_VOID( XGLAPI * real_xglCmdDrawIndexed)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstIndex,
+ XGL_UINT indexCount,
+ XGL_INT vertexOffset,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount) = xglCmdDrawIndexed;
+
+static XGL_VOID( XGLAPI * real_xglCmdDrawIndirect)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride) = xglCmdDrawIndirect;
+
+static XGL_VOID( XGLAPI * real_xglCmdDrawIndexedIndirect)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride) = xglCmdDrawIndexedIndirect;
+
+static XGL_VOID( XGLAPI * real_xglCmdDispatch)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT x,
+ XGL_UINT y,
+ XGL_UINT z) = xglCmdDispatch;
+
+static XGL_VOID( XGLAPI * real_xglCmdDispatchIndirect)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset) = xglCmdDispatchIndirect;
+
+static XGL_VOID( XGLAPI * real_xglCmdCopyMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_COPY* pRegions) = xglCmdCopyMemory;
+
+static XGL_VOID( XGLAPI * real_xglCmdCopyImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_IMAGE_COPY* pRegions) = xglCmdCopyImage;
+
+static XGL_VOID( XGLAPI * real_xglCmdCopyMemoryToImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions) = xglCmdCopyMemoryToImage;
+
+static XGL_VOID( XGLAPI * real_xglCmdCopyImageToMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions) = xglCmdCopyImageToMemory;
+
+static XGL_VOID( XGLAPI * real_xglCmdCloneImageData)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE_STATE srcImageState,
+ XGL_IMAGE destImage,
+ XGL_IMAGE_STATE destImageState) = xglCmdCloneImageData;
+
+static XGL_VOID( XGLAPI * real_xglCmdUpdateMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE dataSize,
+ const XGL_UINT32* pData) = xglCmdUpdateMemory;
+
+static XGL_VOID( XGLAPI * real_xglCmdFillMemory)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE fillSize,
+ XGL_UINT32 data) = xglCmdFillMemory;
+
+static XGL_VOID( XGLAPI * real_xglCmdClearColorImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_FLOAT color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges) = xglCmdClearColorImage;
+
+static XGL_VOID( XGLAPI * real_xglCmdClearColorImageRaw)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_UINT32 color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges) = xglCmdClearColorImageRaw;
+
+static XGL_VOID( XGLAPI * real_xglCmdClearDepthStencil)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ XGL_FLOAT depth,
+ XGL_UINT32 stencil,
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges) = xglCmdClearDepthStencil;
+
+static XGL_VOID( XGLAPI * real_xglCmdResolveImage)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT rectCount,
+ const XGL_IMAGE_RESOLVE* pRects) = xglCmdResolveImage;
+
+static XGL_VOID( XGLAPI * real_xglCmdSetEvent)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event) = xglCmdSetEvent;
+
+static XGL_VOID( XGLAPI * real_xglCmdResetEvent)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event) = xglCmdResetEvent;
+
+static XGL_VOID( XGLAPI * real_xglCmdMemoryAtomic)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_UINT64 srcData,
+ XGL_ATOMIC_OP atomicOp) = xglCmdMemoryAtomic;
+
+static XGL_VOID( XGLAPI * real_xglCmdBeginQuery)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot,
+ XGL_FLAGS flags) = xglCmdBeginQuery;
+
+static XGL_VOID( XGLAPI * real_xglCmdEndQuery)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot) = xglCmdEndQuery;
+
+static XGL_VOID( XGLAPI * real_xglCmdResetQueryPool)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount) = xglCmdResetQueryPool;
+
+static XGL_VOID( XGLAPI * real_xglCmdWriteTimestamp)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_TIMESTAMP_TYPE timestampType,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset) = xglCmdWriteTimestamp;
+
+static XGL_VOID( XGLAPI * real_xglCmdInitAtomicCounters)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ const XGL_UINT32* pData) = xglCmdInitAtomicCounters;
+
+static XGL_VOID( XGLAPI * real_xglCmdLoadAtomicCounters)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_SIZE srcOffset) = xglCmdLoadAtomicCounters;
+
+static XGL_VOID( XGLAPI * real_xglCmdSaveAtomicCounters)(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset) = xglCmdSaveAtomicCounters;
+
+static BOOL isHooked = FALSE;
+
+void AttachHooks()
+{
+ BOOL hookSuccess = TRUE;
+#if defined(WIN32)
+ Mhook_BeginMultiOperation(FALSE);
+ if (real_xglInitAndEnumerateGpus != NULL)
+ {
+ isHooked = TRUE;
+ hookSuccess = Mhook_SetHook((PVOID*)&real_xglInitAndEnumerateGpus, hooked_xglInitAndEnumerateGpus);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetGpuInfo, hooked_xglGetGpuInfo);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateDevice, hooked_xglCreateDevice);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDestroyDevice, hooked_xglDestroyDevice);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetExtensionSupport, hooked_xglGetExtensionSupport);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetDeviceQueue, hooked_xglGetDeviceQueue);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglQueueSubmit, hooked_xglQueueSubmit);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglQueueSetGlobalMemReferences, hooked_xglQueueSetGlobalMemReferences);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglQueueWaitIdle, hooked_xglQueueWaitIdle);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDeviceWaitIdle, hooked_xglDeviceWaitIdle);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetMemoryHeapCount, hooked_xglGetMemoryHeapCount);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetMemoryHeapInfo, hooked_xglGetMemoryHeapInfo);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglAllocMemory, hooked_xglAllocMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglFreeMemory, hooked_xglFreeMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglSetMemoryPriority, hooked_xglSetMemoryPriority);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglMapMemory, hooked_xglMapMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglUnmapMemory, hooked_xglUnmapMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglPinSystemMemory, hooked_xglPinSystemMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglRemapVirtualMemoryPages, hooked_xglRemapVirtualMemoryPages);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetMultiGpuCompatibility, hooked_xglGetMultiGpuCompatibility);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglOpenSharedMemory, hooked_xglOpenSharedMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglOpenSharedQueueSemaphore, hooked_xglOpenSharedQueueSemaphore);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglOpenPeerMemory, hooked_xglOpenPeerMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglOpenPeerImage, hooked_xglOpenPeerImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDestroyObject, hooked_xglDestroyObject);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetObjectInfo, hooked_xglGetObjectInfo);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglBindObjectMemory, hooked_xglBindObjectMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateFence, hooked_xglCreateFence);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetFenceStatus, hooked_xglGetFenceStatus);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglWaitForFences, hooked_xglWaitForFences);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateQueueSemaphore, hooked_xglCreateQueueSemaphore);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglSignalQueueSemaphore, hooked_xglSignalQueueSemaphore);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglWaitQueueSemaphore, hooked_xglWaitQueueSemaphore);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateEvent, hooked_xglCreateEvent);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetEventStatus, hooked_xglGetEventStatus);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglSetEvent, hooked_xglSetEvent);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglResetEvent, hooked_xglResetEvent);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateQueryPool, hooked_xglCreateQueryPool);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetQueryPoolResults, hooked_xglGetQueryPoolResults);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetFormatInfo, hooked_xglGetFormatInfo);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateImage, hooked_xglCreateImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglGetImageSubresourceInfo, hooked_xglGetImageSubresourceInfo);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateImageView, hooked_xglCreateImageView);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateColorAttachmentView, hooked_xglCreateColorAttachmentView);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateDepthStencilView, hooked_xglCreateDepthStencilView);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateShader, hooked_xglCreateShader);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateGraphicsPipeline, hooked_xglCreateGraphicsPipeline);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateComputePipeline, hooked_xglCreateComputePipeline);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglStorePipeline, hooked_xglStorePipeline);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglLoadPipeline, hooked_xglLoadPipeline);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreatePipelineDelta, hooked_xglCreatePipelineDelta);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateSampler, hooked_xglCreateSampler);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateDescriptorSet, hooked_xglCreateDescriptorSet);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglBeginDescriptorSetUpdate, hooked_xglBeginDescriptorSetUpdate);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglEndDescriptorSetUpdate, hooked_xglEndDescriptorSetUpdate);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglAttachSamplerDescriptors, hooked_xglAttachSamplerDescriptors);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglAttachImageViewDescriptors, hooked_xglAttachImageViewDescriptors);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglAttachMemoryViewDescriptors, hooked_xglAttachMemoryViewDescriptors);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglAttachNestedDescriptors, hooked_xglAttachNestedDescriptors);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglClearDescriptorSetSlots, hooked_xglClearDescriptorSetSlots);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateViewportState, hooked_xglCreateViewportState);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateRasterState, hooked_xglCreateRasterState);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateMsaaState, hooked_xglCreateMsaaState);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateColorBlendState, hooked_xglCreateColorBlendState);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateDepthStencilState, hooked_xglCreateDepthStencilState);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCreateCommandBuffer, hooked_xglCreateCommandBuffer);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglBeginCommandBuffer, hooked_xglBeginCommandBuffer);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglEndCommandBuffer, hooked_xglEndCommandBuffer);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglResetCommandBuffer, hooked_xglResetCommandBuffer);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindPipeline, hooked_xglCmdBindPipeline);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindPipelineDelta, hooked_xglCmdBindPipelineDelta);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindStateObject, hooked_xglCmdBindStateObject);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindDescriptorSet, hooked_xglCmdBindDescriptorSet);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindDynamicMemoryView, hooked_xglCmdBindDynamicMemoryView);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindIndexData, hooked_xglCmdBindIndexData);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBindAttachments, hooked_xglCmdBindAttachments);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdPrepareMemoryRegions, hooked_xglCmdPrepareMemoryRegions);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdPrepareImages, hooked_xglCmdPrepareImages);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDraw, hooked_xglCmdDraw);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDrawIndexed, hooked_xglCmdDrawIndexed);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDrawIndirect, hooked_xglCmdDrawIndirect);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDrawIndexedIndirect, hooked_xglCmdDrawIndexedIndirect);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDispatch, hooked_xglCmdDispatch);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDispatchIndirect, hooked_xglCmdDispatchIndirect);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdCopyMemory, hooked_xglCmdCopyMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdCopyImage, hooked_xglCmdCopyImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdCopyMemoryToImage, hooked_xglCmdCopyMemoryToImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdCopyImageToMemory, hooked_xglCmdCopyImageToMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdCloneImageData, hooked_xglCmdCloneImageData);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdUpdateMemory, hooked_xglCmdUpdateMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdFillMemory, hooked_xglCmdFillMemory);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdClearColorImage, hooked_xglCmdClearColorImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdClearColorImageRaw, hooked_xglCmdClearColorImageRaw);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdClearDepthStencil, hooked_xglCmdClearDepthStencil);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdResolveImage, hooked_xglCmdResolveImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdSetEvent, hooked_xglCmdSetEvent);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdResetEvent, hooked_xglCmdResetEvent);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdMemoryAtomic, hooked_xglCmdMemoryAtomic);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdBeginQuery, hooked_xglCmdBeginQuery);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdEndQuery, hooked_xglCmdEndQuery);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdResetQueryPool, hooked_xglCmdResetQueryPool);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdWriteTimestamp, hooked_xglCmdWriteTimestamp);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdInitAtomicCounters, hooked_xglCmdInitAtomicCounters);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdLoadAtomicCounters, hooked_xglCmdLoadAtomicCounters);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdSaveAtomicCounters, hooked_xglCmdSaveAtomicCounters);
+ }
+
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook XGL.");
+ }
+
+ Mhook_EndMultiOperation();
+
+#elif defined(__linux__)
+ if (real_xglInitAndEnumerateGpus == xglInitAndEnumerateGpus)
+ hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglInitAndEnumerateGpus,"xglInitAndEnumerateGpus");
+ isHooked = TRUE;
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetGpuInfo, "xglGetGpuInfo");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateDevice, "xglCreateDevice");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDestroyDevice, "xglDestroyDevice");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetExtensionSupport, "xglGetExtensionSupport");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetDeviceQueue, "xglGetDeviceQueue");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglQueueSubmit, "xglQueueSubmit");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglQueueSetGlobalMemReferences, "xglQueueSetGlobalMemReferences");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglQueueWaitIdle, "xglQueueWaitIdle");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDeviceWaitIdle, "xglDeviceWaitIdle");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetMemoryHeapCount, "xglGetMemoryHeapCount");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetMemoryHeapInfo, "xglGetMemoryHeapInfo");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglAllocMemory, "xglAllocMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglFreeMemory, "xglFreeMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglSetMemoryPriority, "xglSetMemoryPriority");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglMapMemory, "xglMapMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglUnmapMemory, "xglUnmapMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglPinSystemMemory, "xglPinSystemMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglRemapVirtualMemoryPages, "xglRemapVirtualMemoryPages");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetMultiGpuCompatibility, "xglGetMultiGpuCompatibility");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglOpenSharedMemory, "xglOpenSharedMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglOpenSharedQueueSemaphore, "xglOpenSharedQueueSemaphore");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglOpenPeerMemory, "xglOpenPeerMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglOpenPeerImage, "xglOpenPeerImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDestroyObject, "xglDestroyObject");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetObjectInfo, "xglGetObjectInfo");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglBindObjectMemory, "xglBindObjectMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateFence, "xglCreateFence");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetFenceStatus, "xglGetFenceStatus");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglWaitForFences, "xglWaitForFences");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateQueueSemaphore, "xglCreateQueueSemaphore");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglSignalQueueSemaphore, "xglSignalQueueSemaphore");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglWaitQueueSemaphore, "xglWaitQueueSemaphore");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateEvent, "xglCreateEvent");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetEventStatus, "xglGetEventStatus");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglSetEvent, "xglSetEvent");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglResetEvent, "xglResetEvent");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateQueryPool, "xglCreateQueryPool");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetQueryPoolResults, "xglGetQueryPoolResults");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetFormatInfo, "xglGetFormatInfo");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateImage, "xglCreateImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglGetImageSubresourceInfo, "xglGetImageSubresourceInfo");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateImageView, "xglCreateImageView");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateColorAttachmentView, "xglCreateColorAttachmentView");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateDepthStencilView, "xglCreateDepthStencilView");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateShader, "xglCreateShader");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateGraphicsPipeline, "xglCreateGraphicsPipeline");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateComputePipeline, "xglCreateComputePipeline");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglStorePipeline, "xglStorePipeline");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglLoadPipeline, "xglLoadPipeline");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreatePipelineDelta, "xglCreatePipelineDelta");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateSampler, "xglCreateSampler");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateDescriptorSet, "xglCreateDescriptorSet");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglBeginDescriptorSetUpdate, "xglBeginDescriptorSetUpdate");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglEndDescriptorSetUpdate, "xglEndDescriptorSetUpdate");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglAttachSamplerDescriptors, "xglAttachSamplerDescriptors");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglAttachImageViewDescriptors, "xglAttachImageViewDescriptors");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglAttachMemoryViewDescriptors, "xglAttachMemoryViewDescriptors");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglAttachNestedDescriptors, "xglAttachNestedDescriptors");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglClearDescriptorSetSlots, "xglClearDescriptorSetSlots");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateViewportState, "xglCreateViewportState");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateRasterState, "xglCreateRasterState");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateMsaaState, "xglCreateMsaaState");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateColorBlendState, "xglCreateColorBlendState");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateDepthStencilState, "xglCreateDepthStencilState");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCreateCommandBuffer, "xglCreateCommandBuffer");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglBeginCommandBuffer, "xglBeginCommandBuffer");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglEndCommandBuffer, "xglEndCommandBuffer");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglResetCommandBuffer, "xglResetCommandBuffer");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindPipeline, "xglCmdBindPipeline");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindPipelineDelta, "xglCmdBindPipelineDelta");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindStateObject, "xglCmdBindStateObject");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindDescriptorSet, "xglCmdBindDescriptorSet");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindDynamicMemoryView, "xglCmdBindDynamicMemoryView");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindIndexData, "xglCmdBindIndexData");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBindAttachments, "xglCmdBindAttachments");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdPrepareMemoryRegions, "xglCmdPrepareMemoryRegions");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdPrepareImages, "xglCmdPrepareImages");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDraw, "xglCmdDraw");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDrawIndexed, "xglCmdDrawIndexed");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDrawIndirect, "xglCmdDrawIndirect");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDrawIndexedIndirect, "xglCmdDrawIndexedIndirect");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDispatch, "xglCmdDispatch");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDispatchIndirect, "xglCmdDispatchIndirect");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdCopyMemory, "xglCmdCopyMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdCopyImage, "xglCmdCopyImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdCopyMemoryToImage, "xglCmdCopyMemoryToImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdCopyImageToMemory, "xglCmdCopyImageToMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdCloneImageData, "xglCmdCloneImageData");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdUpdateMemory, "xglCmdUpdateMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdFillMemory, "xglCmdFillMemory");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdClearColorImage, "xglCmdClearColorImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdClearColorImageRaw, "xglCmdClearColorImageRaw");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdClearDepthStencil, "xglCmdClearDepthStencil");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdResolveImage, "xglCmdResolveImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdSetEvent, "xglCmdSetEvent");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdResetEvent, "xglCmdResetEvent");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdMemoryAtomic, "xglCmdMemoryAtomic");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdBeginQuery, "xglCmdBeginQuery");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdEndQuery, "xglCmdEndQuery");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdResetQueryPool, "xglCmdResetQueryPool");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdWriteTimestamp, "xglCmdWriteTimestamp");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdInitAtomicCounters, "xglCmdInitAtomicCounters");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdLoadAtomicCounters, "xglCmdLoadAtomicCounters");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdSaveAtomicCounters, "xglCmdSaveAtomicCounters");
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook XGL.");
+ }
+
+#endif
+}
+
+void DetachHooks()
+{
+#ifdef __linux__
+ return;
+#elif defined(WIN32)
+ BOOL unhookSuccess = TRUE;
+ if (real_xglGetGpuInfo != NULL)
+ {
+ unhookSuccess = Mhook_Unhook((PVOID*)&real_xglInitAndEnumerateGpus);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetGpuInfo);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateDevice);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDestroyDevice);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetExtensionSupport);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetDeviceQueue);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglQueueSubmit);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglQueueSetGlobalMemReferences);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglQueueWaitIdle);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDeviceWaitIdle);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetMemoryHeapCount);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetMemoryHeapInfo);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglAllocMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglFreeMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglSetMemoryPriority);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglMapMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglUnmapMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglPinSystemMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglRemapVirtualMemoryPages);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetMultiGpuCompatibility);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglOpenSharedMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglOpenSharedQueueSemaphore);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglOpenPeerMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglOpenPeerImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDestroyObject);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetObjectInfo);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglBindObjectMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateFence);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetFenceStatus);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglWaitForFences);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateQueueSemaphore);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglSignalQueueSemaphore);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglWaitQueueSemaphore);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateEvent);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetEventStatus);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglSetEvent);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglResetEvent);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateQueryPool);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetQueryPoolResults);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetFormatInfo);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglGetImageSubresourceInfo);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateImageView);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateColorAttachmentView);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateDepthStencilView);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateShader);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateGraphicsPipeline);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateComputePipeline);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglStorePipeline);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglLoadPipeline);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreatePipelineDelta);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateSampler);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateDescriptorSet);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglBeginDescriptorSetUpdate);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglEndDescriptorSetUpdate);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglAttachSamplerDescriptors);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglAttachImageViewDescriptors);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglAttachMemoryViewDescriptors);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglAttachNestedDescriptors);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglClearDescriptorSetSlots);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateViewportState);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateRasterState);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateMsaaState);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateColorBlendState);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateDepthStencilState);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCreateCommandBuffer);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglBeginCommandBuffer);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglEndCommandBuffer);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglResetCommandBuffer);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindPipeline);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindPipelineDelta);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindStateObject);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindDescriptorSet);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindDynamicMemoryView);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindIndexData);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBindAttachments);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdPrepareMemoryRegions);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdPrepareImages);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDraw);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDrawIndexed);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDrawIndirect);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDrawIndexedIndirect);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDispatch);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDispatchIndirect);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdCopyMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdCopyImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdCopyMemoryToImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdCopyImageToMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdCloneImageData);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdUpdateMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdFillMemory);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdClearColorImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdClearColorImageRaw);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdClearDepthStencil);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdResolveImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdSetEvent);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdResetEvent);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdMemoryAtomic);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdBeginQuery);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdEndQuery);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdResetQueryPool);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdWriteTimestamp);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdInitAtomicCounters);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdLoadAtomicCounters);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdSaveAtomicCounters);
+ }
+ isHooked = FALSE;
+
+ if (!unhookSuccess)
+ {
+ glv_LogError("Failed to unhook XGL.");
+ }
+#endif
+}
+
+// GPU initialization
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglInitAndEnumerateGpus(
+ const XGL_APPLICATION_INFO* pAppInfo,
+ const XGL_ALLOC_CALLBACKS* pAllocCb,
+ XGL_UINT maxGpus,
+ XGL_UINT* pGpuCount,
+ XGL_PHYSICAL_GPU* pGpus)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ uint64_t startTime;
+ struct_xglInitAndEnumerateGpus* pPacket;
+ SEND_ENTRYPOINT_ID(xglInitAndEnumerateGpus);
+
+ if (real_xglInitAndEnumerateGpus == xglInitAndEnumerateGpus)
+ {
+ glv_platform_get_next_lib_sym((void **) &real_xglInitAndEnumerateGpus,"xglInitAndEnumerateGpus");
+ }
+ startTime = glv_get_time();
+ result = real_xglInitAndEnumerateGpus(pAppInfo, pAllocCb, maxGpus, pGpuCount, pGpus);
+
+ // since we don't know how many gpus will be found must create trace packet after calling xglInit
+ CREATE_TRACE_PACKET(xglInitAndEnumerateGpus, calc_size_XGL_APPLICATION_INFO(pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS))
+ + sizeof(XGL_UINT) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));
+ pHeader->entrypoint_begin_time = startTime;
+ if (isHooked == FALSE) {
+ AttachHooks();
+ AttachHooks_xgldbg();
+ AttachHooks_xglwsix11ext();
+ }
+ pPacket = interpret_body_as_xglInitAndEnumerateGpus(pHeader);
+ add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo);
+ if (pAllocCb) {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocCb), sizeof(XGL_ALLOC_CALLBACKS), pAllocCb);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocCb));
+ }
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpuCount), sizeof(XGL_UINT), pGpuCount);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpuCount));
+ if (pGpuCount && pGpus)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), sizeof(XGL_PHYSICAL_GPU) * *pGpuCount, pGpus);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpus));
+ }
+ pPacket->maxGpus = maxGpus;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetGpuInfo(
+ XGL_PHYSICAL_GPU gpu,
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetGpuInfo* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetGpuInfo);
+ CREATE_TRACE_PACKET(xglGetGpuInfo, ((pDataSize != NULL)? sizeof(XGL_SIZE) : 0) + ((pDataSize != NULL && pData != NULL) ? *pDataSize : 0));
+ result = real_xglGetGpuInfo(gpu, infoType, pDataSize, pData);
+ pPacket = interpret_body_as_xglGetGpuInfo(pHeader);
+ pPacket->gpu = gpu;
+ pPacket->infoType = infoType;
+ pPacket->result = result;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ if (pData && pDataSize)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), *pDataSize, pData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ }
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Device functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateDevice(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo,
+ XGL_DEVICE* pDevice)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateDevice* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateDevice);
+ CREATE_TRACE_PACKET(xglCreateDevice, calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + sizeof(XGL_DEVICE));
+ result = real_xglCreateDevice(gpu, pCreateInfo, pDevice);
+ pPacket = interpret_body_as_xglCreateDevice(pHeader);
+ pPacket->gpu = gpu;
+ add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDevice), sizeof(XGL_DEVICE), pDevice);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDevice));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDestroyDevice(
+ XGL_DEVICE device)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDestroyDevice* pPacket;
+ SEND_ENTRYPOINT_ID(xglDestroyDevice);
+ CREATE_TRACE_PACKET(xglDestroyDevice, 0);
+ result = real_xglDestroyDevice(device);
+ pPacket = interpret_body_as_xglDestroyDevice(pHeader);
+ pPacket->device = device;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Extension discovery functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetExtensionSupport(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_CHAR* pExtName)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetExtensionSupport* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetExtensionSupport);
+ CREATE_TRACE_PACKET(xglGetExtensionSupport, strlen((const char *)pExtName) + 1);
+ result = real_xglGetExtensionSupport(gpu, pExtName);
+ pPacket = interpret_body_as_xglGetExtensionSupport(pHeader);
+ pPacket->gpu = gpu;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pExtName), strlen((const char *)pExtName) + 1, pExtName);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pExtName));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Queue functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetDeviceQueue(
+ XGL_DEVICE device,
+ XGL_QUEUE_TYPE queueType,
+ XGL_UINT queueIndex,
+ XGL_QUEUE* pQueue)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetDeviceQueue* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetDeviceQueue);
+ CREATE_TRACE_PACKET(xglGetDeviceQueue, sizeof(XGL_QUEUE));
+ result = real_xglGetDeviceQueue(device, queueType, queueIndex, pQueue);
+ pPacket = interpret_body_as_xglGetDeviceQueue(pHeader);
+ pPacket->device = device;
+ pPacket->queueType = queueType;
+ pPacket->queueIndex = queueIndex;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pQueue), sizeof(XGL_QUEUE), pQueue);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pQueue));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglQueueSubmit(
+ XGL_QUEUE queue,
+ XGL_UINT cmdBufferCount,
+ const XGL_CMD_BUFFER* pCmdBuffers,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs,
+ XGL_FENCE fence)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglQueueSubmit* pPacket;
+ SEND_ENTRYPOINT_ID(xglQueueSubmit);
+ CREATE_TRACE_PACKET(xglQueueSubmit, cmdBufferCount*sizeof(XGL_CMD_BUFFER) + memRefCount*sizeof(XGL_MEMORY_REF));
+ result = real_xglQueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, fence);
+ pPacket = interpret_body_as_xglQueueSubmit(pHeader);
+ pPacket->queue = queue;
+ pPacket->cmdBufferCount = cmdBufferCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCmdBuffers), cmdBufferCount*sizeof(XGL_CMD_BUFFER), pCmdBuffers);
+ pPacket->memRefCount = memRefCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMemRefs), memRefCount*sizeof(XGL_MEMORY_REF), pMemRefs);
+ pPacket->fence = fence;
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCmdBuffers));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMemRefs));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglQueueSetGlobalMemReferences(
+ XGL_QUEUE queue,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglQueueSetGlobalMemReferences* pPacket;
+ SEND_ENTRYPOINT_ID(xglQueueSetGlobalMemReferences);
+ CREATE_TRACE_PACKET(xglQueueSetGlobalMemReferences, memRefCount*sizeof(XGL_MEMORY_REF));
+ result = real_xglQueueSetGlobalMemReferences(queue, memRefCount, pMemRefs);
+ pPacket = interpret_body_as_xglQueueSetGlobalMemReferences(pHeader);
+ pPacket->queue = queue;
+ pPacket->memRefCount = memRefCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMemRefs), memRefCount*sizeof(XGL_MEMORY_REF), pMemRefs);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMemRefs));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglQueueWaitIdle(
+ XGL_QUEUE queue)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglQueueWaitIdle* pPacket;
+ SEND_ENTRYPOINT_ID(xglQueueWaitIdle);
+ CREATE_TRACE_PACKET(xglQueueWaitIdle, 0);
+ result = real_xglQueueWaitIdle(queue);
+ pPacket = interpret_body_as_xglQueueWaitIdle(pHeader);
+ pPacket->queue = queue;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDeviceWaitIdle(
+ XGL_DEVICE device)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDeviceWaitIdle* pPacket;
+ SEND_ENTRYPOINT_ID(xglDeviceWaitIdle);
+ CREATE_TRACE_PACKET(xglDeviceWaitIdle, 0);
+ result = real_xglDeviceWaitIdle(device);
+ pPacket = interpret_body_as_xglDeviceWaitIdle(pHeader);
+ pPacket->device = device;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Support for shadowing CPU mapped memory
+typedef struct _XGLAllocInfo {
+ XGL_GPU_SIZE size;
+ XGL_GPU_MEMORY handle;
+ XGL_VOID *pData;
+ BOOL valid;
+} XGLAllocInfo;
+typedef struct _XGLMemInfo {
+ unsigned int numEntrys;
+ XGLAllocInfo *pEntrys;
+ XGLAllocInfo *pLastMapped;
+ unsigned int capacity;
+} XGLMemInfo;
+
+static XGLMemInfo mInfo = {0, NULL, NULL, 0};
+
+static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)
+{
+ unsigned int i;
+ for (i = 0; i < num; i++)
+ {
+ XGLAllocInfo *entry = ptr + i;
+ entry->pData = NULL;
+ entry->size = 0;
+ entry->handle = NULL;
+ entry->valid = FALSE;
+ }
+}
+
+static void init_mem_info()
+{
+ mInfo.numEntrys = 0;
+ mInfo.capacity = 1024;
+ mInfo.pLastMapped = NULL;
+
+ mInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, mInfo.capacity);
+
+ if (mInfo.pEntrys == NULL)
+ glv_LogError("init_mem_info() malloc failed\n");
+ else
+ init_mem_info_entrys(mInfo.pEntrys, mInfo.capacity);
+}
+
+static void delete_mem_info()
+{
+ GLV_DELETE(mInfo.pEntrys);
+ mInfo.pEntrys = NULL;
+ mInfo.numEntrys = 0;
+ mInfo.capacity = 0;
+ mInfo.pLastMapped = NULL;
+}
+
+static XGLAllocInfo * get_mem_info_entry()
+{
+ unsigned int i;
+ XGLAllocInfo *entry;
+ if (mInfo.numEntrys > mInfo.capacity)
+ {
+ glv_LogError("get_mem_info_entry() bad internal state numEntrys\n");
+ return NULL;
+ }
+
+ if (mInfo.numEntrys == mInfo.capacity)
+ { // grow the array 2x
+ mInfo.capacity *= 2;
+ mInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(mInfo.pEntrys, mInfo.capacity * sizeof(XGLAllocInfo));
+ //init the newly added entrys
+ init_mem_info_entrys(mInfo.pEntrys + mInfo.capacity / 2, mInfo.capacity / 2);
+ }
+
+ assert(mInfo.numEntrys < mInfo.capacity);
+ entry = mInfo.pEntrys;
+ for (i = 0; i < mInfo.capacity; i++)
+ {
+ if ((entry + i)->valid == FALSE)
+ return entry + i;
+ }
+
+ glv_LogError("get_mem_info_entry() didn't find an entry\n");
+ return NULL;
+}
+
+static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)
+{
+ XGLAllocInfo *entry = mInfo.pEntrys;
+ unsigned int i;
+ if (mInfo.pLastMapped && mInfo.pLastMapped->handle == handle && mInfo.pLastMapped->valid)
+ return mInfo.pLastMapped;
+ for (i = 0; i < mInfo.numEntrys; i++)
+ {
+ if ((entry + i)->valid && (handle == (entry + i)->handle))
+ return entry + i;
+ }
+
+ return NULL;
+}
+
+static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, XGL_VOID *pData)
+{
+ XGLAllocInfo *entry;
+
+ if (mInfo.capacity == 0)
+ init_mem_info();
+
+ entry = get_mem_info_entry();
+ if (entry)
+ {
+ entry->valid = TRUE;
+ entry->handle = handle;
+ entry->size = size;
+ entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()
+ mInfo.numEntrys++;
+ }
+}
+
+static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, XGL_VOID *pData)
+{
+ XGLAllocInfo *entry = find_mem_info_entry(handle);
+
+ if (entry)
+ {
+ entry->pData = pData;
+ }
+ mInfo.pLastMapped = entry;
+}
+
+static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)
+{
+ XGLAllocInfo *entry = find_mem_info_entry(handle);
+
+ if (entry)
+ {
+ entry->valid = FALSE;
+ entry->pData = NULL;
+ entry->size = 0;
+ entry->handle = NULL;
+
+ mInfo.numEntrys--;
+ if (entry == mInfo.pLastMapped)
+ mInfo.pLastMapped = NULL;
+ if (mInfo.numEntrys == 0)
+ delete_mem_info();
+ }
+}
+
+// Memory functions
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetMemoryHeapCount(
+ XGL_DEVICE device,
+ XGL_UINT* pCount)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetMemoryHeapCount* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetMemoryHeapCount);
+ CREATE_TRACE_PACKET(xglGetMemoryHeapCount, sizeof(XGL_UINT));
+ result = real_xglGetMemoryHeapCount(device, pCount);
+ pPacket = interpret_body_as_xglGetMemoryHeapCount(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCount), sizeof(XGL_UINT), pCount);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCount));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetMemoryHeapInfo(
+ XGL_DEVICE device,
+ XGL_UINT heapId,
+ XGL_MEMORY_HEAP_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetMemoryHeapInfo* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetMemoryHeapInfo);
+ CREATE_TRACE_PACKET(xglGetMemoryHeapInfo, ((pDataSize != NULL) ? sizeof(XGL_SIZE) : 0) + ((pDataSize != NULL && pData != NULL)? *pDataSize : 0));
+ result = real_xglGetMemoryHeapInfo(device, heapId, infoType, pDataSize, pData);
+ pPacket = interpret_body_as_xglGetMemoryHeapInfo(pHeader);
+ pPacket->device = device;
+ pPacket->heapId = heapId;
+ pPacket->infoType = infoType;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), (pDataSize != NULL && pData != NULL)? *pDataSize : 0, pData);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglAllocMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglAllocMemory* pPacket;
+ SEND_ENTRYPOINT_PARAMS("xglAllocMemory(device %p, AllocInfo (size %d, align %d, flags %d), pMem %p)\n",
+ device, pAllocInfo->allocationSize, pAllocInfo->alignment, pAllocInfo->flags, pMem);
+ CREATE_TRACE_PACKET(xglAllocMemory, sizeof(XGL_MEMORY_ALLOC_INFO) + sizeof(XGL_GPU_MEMORY));
+ result = real_xglAllocMemory(device, pAllocInfo, pMem);
+ pPacket = interpret_body_as_xglAllocMemory(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(XGL_MEMORY_ALLOC_INFO), pAllocInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(XGL_GPU_MEMORY), pMem);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader,(void**)&(pPacket->pAllocInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ FINISH_TRACE_PACKET();
+ add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglFreeMemory(
+ XGL_GPU_MEMORY mem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglFreeMemory* pPacket;
+ SEND_ENTRYPOINT_PARAMS("xglFreeMemory( mem %p)\n", mem);
+ CREATE_TRACE_PACKET(xglFreeMemory, 0);
+ result = real_xglFreeMemory(mem);
+ pPacket = interpret_body_as_xglFreeMemory(pHeader);
+ pPacket->mem = mem;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ rm_handle_from_mem_info(mem);
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglSetMemoryPriority(
+ XGL_GPU_MEMORY mem,
+ XGL_MEMORY_PRIORITY priority)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglSetMemoryPriority* pPacket;
+ SEND_ENTRYPOINT_ID(xglSetMemoryPriority);
+ CREATE_TRACE_PACKET(xglSetMemoryPriority, 0);
+ result = real_xglSetMemoryPriority(mem, priority);
+ pPacket = interpret_body_as_xglSetMemoryPriority(pHeader);
+ pPacket->mem = mem;
+ pPacket->priority = priority;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglMapMemory(
+ XGL_GPU_MEMORY mem,
+ XGL_FLAGS flags, // Reserved
+ XGL_VOID** ppData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglMapMemory* pPacket;
+ SEND_ENTRYPOINT_PARAMS("xglMapMemory(mem %p, flags %u, ppData %p)\n", mem, flags, ppData);
+ CREATE_TRACE_PACKET(xglMapMemory, sizeof(XGL_VOID*));
+ result = real_xglMapMemory(mem, flags, ppData);
+ pPacket = interpret_body_as_xglMapMemory(pHeader);
+ pPacket->mem = mem;
+ pPacket->flags = flags;
+ if (ppData != NULL)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(XGL_VOID*), *ppData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));
+ add_data_to_mem_info(mem, *ppData);
+ }
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(
+ XGL_GPU_MEMORY mem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglUnmapMemory* pPacket;
+ XGLAllocInfo *entry;
+ SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\n", mem);
+ // insert into packet the data that was written by CPU between the xglMapMemory call and here
+ // Note must do this prior to the real xglUnMap() or else may get a FAULT
+ entry = find_mem_info_entry(mem);
+ CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);
+ pPacket = interpret_body_as_xglUnmapMemory(pHeader);
+
+ if (entry)
+ {
+ assert(entry->handle == mem);
+ glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ entry->pData = NULL;
+ }
+ result = real_xglUnmapMemory(mem);
+ pPacket->mem = mem;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglPinSystemMemory(
+ XGL_DEVICE device,
+ const XGL_VOID* pSysMem,
+ XGL_SIZE memSize,
+ XGL_GPU_MEMORY* pMem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglPinSystemMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglPinSystemMemory);
+ CREATE_TRACE_PACKET(xglPinSystemMemory, sizeof(XGL_GPU_MEMORY));
+ result = real_xglPinSystemMemory(device, pSysMem, memSize, pMem);
+ pPacket = interpret_body_as_xglPinSystemMemory(pHeader);
+ pPacket->device = device;
+ pPacket->pSysMem = pSysMem;
+ pPacket->memSize = memSize;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(XGL_GPU_MEMORY), pMem);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglRemapVirtualMemoryPages(
+ XGL_DEVICE device,
+ XGL_UINT rangeCount,
+ const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
+ XGL_UINT preWaitSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
+ XGL_UINT postSignalSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglRemapVirtualMemoryPages* pPacket;
+ SEND_ENTRYPOINT_ID(xglRemapVirtualMemoryPages);
+ CREATE_TRACE_PACKET(xglRemapVirtualMemoryPages, rangeCount*sizeof(XGL_VIRTUAL_MEMORY_REMAP_RANGE) + preWaitSemaphoreCount*sizeof(XGL_QUEUE_SEMAPHORE) + postSignalSemaphoreCount*sizeof(XGL_QUEUE_SEMAPHORE));
+ result = real_xglRemapVirtualMemoryPages(device, rangeCount, pRanges, preWaitSemaphoreCount, pPreWaitSemaphores, postSignalSemaphoreCount, pPostSignalSemaphores);
+ pPacket = interpret_body_as_xglRemapVirtualMemoryPages(pHeader);
+ pPacket->device = device;
+ pPacket->rangeCount = rangeCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRanges), rangeCount*sizeof(XGL_VIRTUAL_MEMORY_REMAP_RANGE), pRanges);
+ pPacket->preWaitSemaphoreCount = preWaitSemaphoreCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPreWaitSemaphores), preWaitSemaphoreCount*sizeof(XGL_QUEUE_SEMAPHORE), pPreWaitSemaphores);
+ pPacket->postSignalSemaphoreCount = postSignalSemaphoreCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPostSignalSemaphores), postSignalSemaphoreCount*sizeof(XGL_QUEUE_SEMAPHORE), pPostSignalSemaphores);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRanges));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPreWaitSemaphores));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPostSignalSemaphores));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Multi-device functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetMultiGpuCompatibility(
+ XGL_PHYSICAL_GPU gpu0,
+ XGL_PHYSICAL_GPU gpu1,
+ XGL_GPU_COMPATIBILITY_INFO* pInfo)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetMultiGpuCompatibility* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetMultiGpuCompatibility);
+ CREATE_TRACE_PACKET(xglGetMultiGpuCompatibility, sizeof(XGL_GPU_COMPATIBILITY_INFO));
+ result = real_xglGetMultiGpuCompatibility(gpu0, gpu1, pInfo);
+ pPacket = interpret_body_as_xglGetMultiGpuCompatibility(pHeader);
+ pPacket->gpu0 = gpu0;
+ pPacket->gpu1 = gpu1;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInfo), sizeof(XGL_GPU_COMPATIBILITY_INFO), pInfo);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pInfo));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglOpenSharedMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglOpenSharedMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglOpenSharedMemory);
+ CREATE_TRACE_PACKET(xglOpenSharedMemory, sizeof(XGL_MEMORY_OPEN_INFO) + sizeof(XGL_GPU_MEMORY));
+ result = real_xglOpenSharedMemory(device, pOpenInfo, pMem);
+ pPacket = interpret_body_as_xglOpenSharedMemory(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOpenInfo), sizeof(XGL_MEMORY_OPEN_INFO), pOpenInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(XGL_GPU_MEMORY), pMem);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOpenInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglOpenSharedQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglOpenSharedQueueSemaphore* pPacket;
+ SEND_ENTRYPOINT_ID(xglOpenSharedQueueSemaphore);
+ CREATE_TRACE_PACKET(xglOpenSharedQueueSemaphore, sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO) + sizeof(XGL_QUEUE_SEMAPHORE));
+ result = real_xglOpenSharedQueueSemaphore(device, pOpenInfo, pSemaphore);
+ pPacket = interpret_body_as_xglOpenSharedQueueSemaphore(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOpenInfo), sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO), pOpenInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSemaphore), sizeof(XGL_QUEUE_SEMAPHORE), pSemaphore);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOpenInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSemaphore));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglOpenPeerMemory(
+ XGL_DEVICE device,
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglOpenPeerMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglOpenPeerMemory);
+ CREATE_TRACE_PACKET(xglOpenPeerMemory, sizeof(XGL_PEER_MEMORY_OPEN_INFO) + sizeof(XGL_GPU_MEMORY));
+ result = real_xglOpenPeerMemory(device, pOpenInfo, pMem);
+ pPacket = interpret_body_as_xglOpenPeerMemory(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOpenInfo), sizeof(XGL_PEER_MEMORY_OPEN_INFO), pOpenInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(XGL_GPU_MEMORY), pMem);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOpenInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglOpenPeerImage(
+ XGL_DEVICE device,
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglOpenPeerImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglOpenPeerImage);
+ CREATE_TRACE_PACKET(xglOpenPeerImage, sizeof(XGL_PEER_IMAGE_OPEN_INFO) + sizeof(XGL_IMAGE) + sizeof(XGL_GPU_MEMORY));
+ result = real_xglOpenPeerImage(device, pOpenInfo, pImage, pMem);
+ pPacket = interpret_body_as_xglOpenPeerImage(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOpenInfo), sizeof(XGL_PEER_IMAGE_OPEN_INFO), pOpenInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pImage), sizeof(XGL_IMAGE), pImage);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(XGL_GPU_MEMORY), pMem);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOpenInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImage));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Generic API object functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDestroyObject(
+ XGL_OBJECT object)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDestroyObject* pPacket;
+ SEND_ENTRYPOINT_ID(xglDestroyObject);
+ CREATE_TRACE_PACKET(xglDestroyObject, 0);
+ result = real_xglDestroyObject(object);
+ pPacket = interpret_body_as_xglDestroyObject(pHeader);
+ pPacket->object = object;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetObjectInfo(
+ XGL_BASE_OBJECT object,
+ XGL_OBJECT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetObjectInfo* pPacket;
+ uint64_t startTime;
+ SEND_ENTRYPOINT_ID(xglGetObjectInfo);
+ startTime = glv_get_time();
+ result = real_xglGetObjectInfo(object, infoType, pDataSize, pData);
+ // since don't know the size of *pDataSize potentially until after the call create trace packet post call
+ CREATE_TRACE_PACKET(xglGetObjectInfo, ((pDataSize != NULL) ? sizeof(XGL_SIZE) : 0) + ((pDataSize != NULL)? *pDataSize : 0));
+ pHeader->entrypoint_begin_time = startTime;
+ pPacket = interpret_body_as_xglGetObjectInfo(pHeader);
+ pPacket->object = object;
+ pPacket->infoType = infoType;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ if (pDataSize && pData)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), *pDataSize, pData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ }
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglBindObjectMemory(
+ XGL_OBJECT object,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglBindObjectMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglBindObjectMemory);
+ CREATE_TRACE_PACKET(xglBindObjectMemory, 0);
+ result = real_xglBindObjectMemory(object, mem, offset);
+ pPacket = interpret_body_as_xglBindObjectMemory(pHeader);
+ pPacket->object = object;
+ pPacket->mem = mem;
+ pPacket->offset = offset;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Fence functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateFence(
+ XGL_DEVICE device,
+ const XGL_FENCE_CREATE_INFO* pCreateInfo,
+ XGL_FENCE* pFence)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateFence* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateFence);
+ CREATE_TRACE_PACKET(xglCreateFence, sizeof(XGL_FENCE_CREATE_INFO) + sizeof(XGL_FENCE));
+ result = real_xglCreateFence(device, pCreateInfo, pFence);
+ pPacket = interpret_body_as_xglCreateFence(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_FENCE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pFence), sizeof(XGL_FENCE), pFence);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pFence));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetFenceStatus(
+ XGL_FENCE fence)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetFenceStatus* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetFenceStatus);
+ CREATE_TRACE_PACKET(xglGetFenceStatus, 0);
+ result = real_xglGetFenceStatus(fence);
+ pPacket = interpret_body_as_xglGetFenceStatus(pHeader);
+ pPacket->fence = fence;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglWaitForFences(
+ XGL_DEVICE device,
+ XGL_UINT fenceCount,
+ const XGL_FENCE* pFences,
+ XGL_BOOL waitAll,
+ XGL_UINT64 timeout)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglWaitForFences* pPacket;
+ SEND_ENTRYPOINT_ID(xglWaitForFences);
+ CREATE_TRACE_PACKET(xglWaitForFences, fenceCount*sizeof(XGL_FENCE));
+ result = real_xglWaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ pPacket = interpret_body_as_xglWaitForFences(pHeader);
+ pPacket->device = device;
+ pPacket->fenceCount = fenceCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pFences), fenceCount*sizeof(XGL_FENCE), pFences);
+ pPacket->waitAll = waitAll;
+ pPacket->timeout = timeout;
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pFences));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Queue semaphore functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateQueueSemaphore* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateQueueSemaphore);
+ CREATE_TRACE_PACKET(xglCreateQueueSemaphore, sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO) + sizeof(XGL_QUEUE_SEMAPHORE));
+ result = real_xglCreateQueueSemaphore(device, pCreateInfo, pSemaphore);
+ pPacket = interpret_body_as_xglCreateQueueSemaphore(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSemaphore), sizeof(XGL_QUEUE_SEMAPHORE), pSemaphore);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSemaphore));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglSignalQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglSignalQueueSemaphore* pPacket;
+ SEND_ENTRYPOINT_ID(xglSignalQueueSemaphore);
+ CREATE_TRACE_PACKET(xglSignalQueueSemaphore, 0);
+ result = real_xglSignalQueueSemaphore(queue, semaphore);
+ pPacket = interpret_body_as_xglSignalQueueSemaphore(pHeader);
+ pPacket->queue = queue;
+ pPacket->semaphore = semaphore;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglWaitQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglWaitQueueSemaphore* pPacket;
+ SEND_ENTRYPOINT_ID(xglWaitQueueSemaphore);
+ CREATE_TRACE_PACKET(xglWaitQueueSemaphore, 0);
+ result = real_xglWaitQueueSemaphore(queue, semaphore);
+ pPacket = interpret_body_as_xglWaitQueueSemaphore(pHeader);
+ pPacket->queue = queue;
+ pPacket->semaphore = semaphore;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Event functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateEvent(
+ XGL_DEVICE device,
+ const XGL_EVENT_CREATE_INFO* pCreateInfo,
+ XGL_EVENT* pEvent)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateEvent* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateEvent);
+ CREATE_TRACE_PACKET(xglCreateEvent, sizeof(XGL_EVENT_CREATE_INFO) + sizeof(XGL_EVENT));
+ result = real_xglCreateEvent(device, pCreateInfo, pEvent);
+ pPacket = interpret_body_as_xglCreateEvent(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_EVENT_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pEvent), sizeof(XGL_EVENT), pEvent);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pEvent));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetEventStatus(
+ XGL_EVENT event)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetEventStatus* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetEventStatus);
+ CREATE_TRACE_PACKET(xglGetEventStatus, 0);
+ result = real_xglGetEventStatus(event);
+ pPacket = interpret_body_as_xglGetEventStatus(pHeader);
+ pPacket->event = event;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglSetEvent(
+ XGL_EVENT event)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglSetEvent* pPacket;
+ SEND_ENTRYPOINT_ID(xglSetEvent);
+ CREATE_TRACE_PACKET(xglSetEvent, 0);
+ result = real_xglSetEvent(event);
+ pPacket = interpret_body_as_xglSetEvent(pHeader);
+ pPacket->event = event;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglResetEvent(
+ XGL_EVENT event)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglResetEvent* pPacket;
+ SEND_ENTRYPOINT_ID(xglResetEvent);
+ CREATE_TRACE_PACKET(xglResetEvent, 0);
+ result = real_xglResetEvent(event);
+ pPacket = interpret_body_as_xglResetEvent(pHeader);
+ pPacket->event = event;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Query functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateQueryPool(
+ XGL_DEVICE device,
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ XGL_QUERY_POOL* pQueryPool)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateQueryPool* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateQueryPool);
+ CREATE_TRACE_PACKET(xglCreateQueryPool, sizeof(XGL_QUERY_POOL) + sizeof(XGL_QUERY_POOL_CREATE_INFO));
+ result = real_xglCreateQueryPool(device, pCreateInfo, pQueryPool);
+ pPacket = interpret_body_as_xglCreateQueryPool(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_QUERY_POOL_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pQueryPool), sizeof(XGL_QUERY_POOL), pQueryPool);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pQueryPool));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetQueryPoolResults(
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetQueryPoolResults* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetQueryPoolResults);
+ CREATE_TRACE_PACKET(xglGetQueryPoolResults, ((pDataSize != NULL ) ? sizeof(XGL_SIZE) : 0) + ((pDataSize != NULL && pData != NULL) ? *pDataSize : 0));
+ result = real_xglGetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
+ pPacket = interpret_body_as_xglGetQueryPoolResults(pHeader);
+ pPacket->queryPool = queryPool;
+ pPacket->startQuery = startQuery;
+ pPacket->queryCount = queryCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), (pDataSize != NULL && pData != NULL) ? *pDataSize : 0, pData);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Format capabilities
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetFormatInfo(
+ XGL_DEVICE device,
+ XGL_FORMAT format,
+ XGL_FORMAT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetFormatInfo* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetFormatInfo);
+ CREATE_TRACE_PACKET(xglGetFormatInfo, ((pDataSize != NULL ) ? sizeof(XGL_SIZE) : 0) + ((pDataSize != NULL && pData != NULL) ? *pDataSize : 0));
+ result = real_xglGetFormatInfo(device, format, infoType, pDataSize, pData);
+ pPacket = interpret_body_as_xglGetFormatInfo(pHeader);
+ pPacket->device = device;
+ pPacket->format = format;
+ pPacket->infoType = infoType;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), (pDataSize != NULL && pData != NULL) ? *pDataSize : 0, pData);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Image functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateImage(
+ XGL_DEVICE device,
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateImage);
+ CREATE_TRACE_PACKET(xglCreateImage, sizeof(XGL_IMAGE_CREATE_INFO) + sizeof(XGL_IMAGE));
+ result = real_xglCreateImage(device, pCreateInfo, pImage);
+ pPacket = interpret_body_as_xglCreateImage(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_IMAGE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pImage), sizeof(XGL_IMAGE), pImage);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImage));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglGetImageSubresourceInfo(
+ XGL_IMAGE image,
+ const XGL_IMAGE_SUBRESOURCE* pSubresource,
+ XGL_SUBRESOURCE_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglGetImageSubresourceInfo* pPacket;
+ SEND_ENTRYPOINT_ID(xglGetImageSubresourceInfo);
+ CREATE_TRACE_PACKET(xglGetImageSubresourceInfo, ((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0) + ((pDataSize != NULL ) ? sizeof(XGL_SIZE) : 0) + ((pDataSize != NULL && pData != NULL) ? *pDataSize : 0));
+ result = real_xglGetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
+ pPacket = interpret_body_as_xglGetImageSubresourceInfo(pHeader);
+ pPacket->image = image;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSubresource), sizeof(XGL_IMAGE_SUBRESOURCE), pSubresource);
+ pPacket->infoType = infoType;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), (pDataSize != NULL && pData != NULL) ? *pDataSize : 0, pData);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSubresource));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Image view functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateImageView(
+ XGL_DEVICE device,
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE_VIEW* pView)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateImageView* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateImageView);
+ CREATE_TRACE_PACKET(xglCreateImageView, sizeof(XGL_IMAGE_VIEW_CREATE_INFO) + sizeof(XGL_IMAGE_VIEW));
+ result = real_xglCreateImageView(device, pCreateInfo, pView);
+ pPacket = interpret_body_as_xglCreateImageView(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_IMAGE_VIEW_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pView), sizeof(XGL_IMAGE_VIEW), pView);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pView));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateColorAttachmentView(
+ XGL_DEVICE device,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_ATTACHMENT_VIEW* pView)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateColorAttachmentView* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateColorAttachmentView);
+ CREATE_TRACE_PACKET(xglCreateColorAttachmentView, sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO)+sizeof(XGL_COLOR_ATTACHMENT_VIEW));
+ result = real_xglCreateColorAttachmentView(device, pCreateInfo, pView);
+ pPacket = interpret_body_as_xglCreateColorAttachmentView(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pView), sizeof(XGL_COLOR_ATTACHMENT_VIEW), pView);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pView));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateDepthStencilView(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_VIEW* pView)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateDepthStencilView* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateDepthStencilView);
+ CREATE_TRACE_PACKET(xglCreateDepthStencilView, sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO) + sizeof(XGL_DEPTH_STENCIL_VIEW));
+ result = real_xglCreateDepthStencilView(device, pCreateInfo, pView);
+ pPacket = interpret_body_as_xglCreateDepthStencilView(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pView), sizeof(XGL_DEPTH_STENCIL_VIEW), pView);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pView));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Shader functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateShader(
+ XGL_DEVICE device,
+ const XGL_SHADER_CREATE_INFO* pCreateInfo,
+ XGL_SHADER* pShader)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateShader* pPacket;
+ size_t shaderCodeSize;
+ SEND_ENTRYPOINT_ID(xglCreateShader);
+ shaderCodeSize = (pCreateInfo != NULL) ? pCreateInfo->codeSize : 0;
+ CREATE_TRACE_PACKET(xglCreateShader, sizeof(XGL_SHADER_CREATE_INFO) + sizeof(XGL_SHADER) + shaderCodeSize);
+ result = real_xglCreateShader(device, pCreateInfo, pShader);
+ pPacket = interpret_body_as_xglCreateShader(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_SHADER_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), shaderCodeSize, pCreateInfo->pCode);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pShader), sizeof(XGL_SHADER), pShader);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pShader));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Pipeline functions
+
+static size_t calculate_pipeline_shader_size(const XGL_PIPELINE_SHADER* shader)
+{
+ size_t size = 0;
+ XGL_UINT i, j;
+
+ size += sizeof(XGL_PIPELINE_SHADER);
+ // descriptor sets
+ for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)
+ {
+ for (j = 0; j < shader->descriptorSetMapping[i].descriptorCount; j++)
+ {
+ size += sizeof(XGL_DESCRIPTOR_SLOT_INFO);
+ if (shader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)
+ {
+ size += sizeof(XGL_DESCRIPTOR_SET_MAPPING);
+ }
+ }
+ }
+
+ // constant buffers
+ if (shader->linkConstBufferCount > 0 && shader->pLinkConstBufferInfo != NULL)
+ {
+ XGL_UINT i;
+ for (i = 0; i < shader->linkConstBufferCount; i++)
+ {
+ size += sizeof(XGL_LINK_CONST_BUFFER);
+ size += shader->pLinkConstBufferInfo[i].bufferSize;
+ }
+ }
+ return size;
+}
+
+static void add_pipeline_shader_to_trace_packet(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* packetShader, const XGL_PIPELINE_SHADER* paramShader)
+{
+ XGL_UINT i, j;
+ // descriptor sets
+ for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo), sizeof(XGL_DESCRIPTOR_SLOT_INFO)* paramShader->descriptorSetMapping[i].descriptorCount, paramShader->descriptorSetMapping[i].pDescriptorInfo);
+ for (j = 0; j < paramShader->descriptorSetMapping[i].descriptorCount; j++)
+ {
+ if (paramShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet), sizeof(XGL_DESCRIPTOR_SET_MAPPING), paramShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet);
+ }
+ }
+ packetShader->descriptorSetMapping[i].descriptorCount = paramShader->descriptorSetMapping[i].descriptorCount;
+ }
+
+ // constant buffers
+ if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);
+ for (i = 0; i < paramShader->linkConstBufferCount; i++)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);
+ }
+ }
+}
+
+static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)
+{
+ XGL_UINT i, j;
+ // descriptor sets
+ for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)
+ {
+ for (j = 0; j < packetShader->descriptorSetMapping[i].descriptorCount; j++)
+ {
+ if (packetShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)
+ {
+ glv_finalize_buffer_address(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet));
+ }
+ }
+ glv_finalize_buffer_address(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo));
+ }
+
+ // constant buffers
+ if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)
+ {
+ for (i = 0; i < packetShader->linkConstBufferCount; i++)
+ {
+ glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));
+ }
+ glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));
+ }
+}
+
+static size_t calculate_pipeline_state_size(const XGL_VOID* pState)
+{
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pNext = pState;
+ size_t totalStateSize = 0;
+ while (pNext)
+ {
+ switch (pNext->sType)
+ {
+ //case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ // totalStateSize += sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
+ // break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ totalStateSize += sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ totalStateSize += sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ totalStateSize += sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
+ totalStateSize += sizeof(XGL_PIPELINE_DB_STATE_CREATE_INFO);
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ totalStateSize += sizeof(XGL_PIPELINE_CB_STATE);
+ break;
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ {
+ const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pShaderStage = (const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext;
+ totalStateSize += (sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) + calculate_pipeline_shader_size(&pShaderStage->shader));
+ break;
+ }
+ //case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ // totalStateSize += sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
+ // break;
+ default:
+ assert(0);
+ }
+ pNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pNext->pNext;
+ }
+ return totalStateSize;
+}
+
+static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, XGL_VOID** ppOut, const XGL_VOID* pIn)
+{
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;
+ while (pInNow != NULL)
+ {
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;
+ ppOutNext = NULL;
+
+ switch (pInNow->sType)
+ {
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO), pInNow);
+ ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;
+ glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO), pInNow);
+ ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;
+ glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO), pInNow);
+ ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;
+ glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_DB_STATE_CREATE_INFO), pInNow);
+ ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;
+ glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_CB_STATE), pInNow);
+ ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;
+ glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ {
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);
+ pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;
+ pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;
+ add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);
+ finalize_pipeline_shader_address(pHeader, &pPacket->shader);
+ ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;
+ glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));
+ break;
+ }
+ default:
+ assert(!"Encountered an unexpected type in pipeline state list");
+ }
+ pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;
+ }
+ return;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateGraphicsPipeline(
+ XGL_DEVICE device,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ size_t stateSize;
+ struct_xglCreateGraphicsPipeline* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateGraphicsPipeline);
+ stateSize = calculate_pipeline_state_size(pCreateInfo->pNext);
+ CREATE_TRACE_PACKET(xglCreateGraphicsPipeline, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + stateSize);
+ result = real_xglCreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ pPacket = interpret_body_as_xglCreateGraphicsPipeline(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), pCreateInfo);
+ add_pipeline_state_to_trace_packet(pHeader, (XGL_VOID**)&pPacket->pCreateInfo->pNext, pCreateInfo->pNext);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipeline), sizeof(XGL_PIPELINE), pPipeline);
+ pPacket->result = result;
+ // finalize the addresses in the pipeline state list is done in add_pipeline_state_to_trace_packet()
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipeline));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateComputePipeline(
+ XGL_DEVICE device,
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ size_t stateSize;
+ struct_xglCreateComputePipeline* pPacket = NULL;
+ SEND_ENTRYPOINT_ID(xglCreateComputePipeline);
+ stateSize = calculate_pipeline_state_size(pCreateInfo->pNext);
+ CREATE_TRACE_PACKET(xglCreateComputePipeline, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + stateSize + calculate_pipeline_shader_size(&pCreateInfo->cs));
+ result = real_xglCreateComputePipeline(device, pCreateInfo, pPipeline);
+ pPacket = interpret_body_as_xglCreateComputePipeline(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO), pCreateInfo);
+ add_pipeline_state_to_trace_packet(pHeader, (XGL_VOID**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);
+ add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipeline), sizeof(XGL_PIPELINE), pPipeline);
+ pPacket->result = result;
+ // finalize the addresses in the pipeline state list is done in add_pipeline_state_to_trace_packet()
+ finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipeline));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglStorePipeline(
+ XGL_PIPELINE pipeline,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglStorePipeline* pPacket;
+ SEND_ENTRYPOINT_ID(xglStorePipeline);
+ CREATE_TRACE_PACKET(xglStorePipeline, sizeof(XGL_SIZE) + ((pDataSize != NULL) ? *pDataSize : 0));
+ result = real_xglStorePipeline(pipeline, pDataSize, pData);
+ pPacket = interpret_body_as_xglStorePipeline(pHeader);
+ pPacket->pipeline = pipeline;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDataSize), sizeof(XGL_SIZE), pDataSize);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), (pDataSize != NULL) ? *pDataSize : 0, pData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDataSize));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglLoadPipeline(
+ XGL_DEVICE device,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData,
+ XGL_PIPELINE* pPipeline)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglLoadPipeline* pPacket;
+ SEND_ENTRYPOINT_ID(xglLoadPipeline);
+ CREATE_TRACE_PACKET(xglLoadPipeline, dataSize + sizeof(XGL_PIPELINE));
+ result = real_xglLoadPipeline(device, dataSize, pData, pPipeline);
+ pPacket = interpret_body_as_xglLoadPipeline(pHeader);
+ pPacket->device = device;
+ pPacket->dataSize = dataSize;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), dataSize, pData);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipeline), sizeof(XGL_PIPELINE), pPipeline);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipeline));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreatePipelineDelta(
+ XGL_DEVICE device,
+ XGL_PIPELINE p1,
+ XGL_PIPELINE p2,
+ XGL_PIPELINE_DELTA* delta)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreatePipelineDelta* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreatePipelineDelta);
+ CREATE_TRACE_PACKET(xglCreatePipelineDelta, sizeof(XGL_PIPELINE_DELTA));
+ result = real_xglCreatePipelineDelta(device, p1, p2, delta);
+ pPacket = interpret_body_as_xglCreatePipelineDelta(pHeader);
+ pPacket->device = device;
+ pPacket->p1 = p1;
+ pPacket->p2 = p2;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->delta), sizeof(XGL_PIPELINE_DELTA), delta);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->delta));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Sampler functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateSampler(
+ XGL_DEVICE device,
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
+ XGL_SAMPLER* pSampler)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateSampler* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateSampler);
+ CREATE_TRACE_PACKET(xglCreateSampler, sizeof(XGL_SAMPLER_CREATE_INFO) + sizeof(XGL_SAMPLER));
+ result = real_xglCreateSampler(device, pCreateInfo, pSampler);
+ pPacket = interpret_body_as_xglCreateSampler(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_SAMPLER_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSampler), sizeof(XGL_SAMPLER), pSampler);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSampler));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Descriptor set functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateDescriptorSet(
+ XGL_DEVICE device,
+ const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_SET* pDescriptorSet)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateDescriptorSet* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateDescriptorSet);
+ CREATE_TRACE_PACKET(xglCreateDescriptorSet, sizeof(XGL_DESCRIPTOR_SET_CREATE_INFO) + sizeof(XGL_DESCRIPTOR_SET));
+ result = real_xglCreateDescriptorSet(device, pCreateInfo, pDescriptorSet);
+ pPacket = interpret_body_as_xglCreateDescriptorSet(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DESCRIPTOR_SET_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSet), sizeof(XGL_DESCRIPTOR_SET), pDescriptorSet);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorSet));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglBeginDescriptorSetUpdate(
+ XGL_DESCRIPTOR_SET descriptorSet)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglBeginDescriptorSetUpdate* pPacket;
+ SEND_ENTRYPOINT_ID(xglBeginDescriptorSetUpdate);
+ CREATE_TRACE_PACKET(xglBeginDescriptorSetUpdate, 0);
+ real_xglBeginDescriptorSetUpdate(descriptorSet);
+ pPacket = interpret_body_as_xglBeginDescriptorSetUpdate(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglEndDescriptorSetUpdate(
+ XGL_DESCRIPTOR_SET descriptorSet)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglEndDescriptorSetUpdate* pPacket;
+ SEND_ENTRYPOINT_ID(xglEndDescriptorSetUpdate);
+ CREATE_TRACE_PACKET(xglEndDescriptorSetUpdate, 0);
+ real_xglEndDescriptorSetUpdate(descriptorSet);
+ pPacket = interpret_body_as_xglEndDescriptorSetUpdate(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglAttachSamplerDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_SAMPLER* pSamplers)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglAttachSamplerDescriptors* pPacket;
+ SEND_ENTRYPOINT_ID(xglAttachSamplerDescriptors);
+ CREATE_TRACE_PACKET(xglAttachSamplerDescriptors, slotCount*sizeof(XGL_SAMPLER));
+ real_xglAttachSamplerDescriptors(descriptorSet, startSlot, slotCount, pSamplers);
+ pPacket = interpret_body_as_xglAttachSamplerDescriptors(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ pPacket->startSlot = startSlot;
+ pPacket->slotCount = slotCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pSamplers), slotCount*sizeof(XGL_SAMPLER), pSamplers);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplers));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglAttachImageViewDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglAttachImageViewDescriptors* pPacket;
+ SEND_ENTRYPOINT_ID(xglAttachImageViewDescriptors);
+ CREATE_TRACE_PACKET(xglAttachImageViewDescriptors, slotCount*sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));
+ real_xglAttachImageViewDescriptors(descriptorSet, startSlot, slotCount, pImageViews);
+ pPacket = interpret_body_as_xglAttachImageViewDescriptors(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ pPacket->startSlot = startSlot;
+ pPacket->slotCount = slotCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pImageViews), slotCount*sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), pImageViews);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglAttachMemoryViewDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglAttachMemoryViewDescriptors* pPacket;
+ SEND_ENTRYPOINT_ID(xglAttachMemoryViewDescriptors);
+ CREATE_TRACE_PACKET(xglAttachMemoryViewDescriptors, slotCount*sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));
+ real_xglAttachMemoryViewDescriptors(descriptorSet, startSlot, slotCount, pMemViews);
+ pPacket = interpret_body_as_xglAttachMemoryViewDescriptors(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ pPacket->startSlot = startSlot;
+ pPacket->slotCount = slotCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMemViews), slotCount*sizeof(XGL_MEMORY_VIEW_ATTACH_INFO), pMemViews);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMemViews));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglAttachNestedDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglAttachNestedDescriptors* pPacket;
+ SEND_ENTRYPOINT_ID(xglAttachNestedDescriptors);
+ CREATE_TRACE_PACKET(xglAttachNestedDescriptors, slotCount*sizeof(XGL_DESCRIPTOR_SET_ATTACH_INFO));
+ real_xglAttachNestedDescriptors(descriptorSet, startSlot, slotCount, pNestedDescriptorSets);
+ pPacket = interpret_body_as_xglAttachNestedDescriptors(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ pPacket->startSlot = startSlot;
+ pPacket->slotCount = slotCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pNestedDescriptorSets), slotCount*sizeof(XGL_DESCRIPTOR_SET_ATTACH_INFO), pNestedDescriptorSets);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pNestedDescriptorSets));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglClearDescriptorSetSlots(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglClearDescriptorSetSlots* pPacket;
+ SEND_ENTRYPOINT_ID(xglClearDescriptorSetSlots);
+ CREATE_TRACE_PACKET(xglClearDescriptorSetSlots, 0);
+ real_xglClearDescriptorSetSlots(descriptorSet, startSlot, slotCount);
+ pPacket = interpret_body_as_xglClearDescriptorSetSlots(pHeader);
+ pPacket->descriptorSet = descriptorSet;
+ pPacket->startSlot = startSlot;
+ pPacket->slotCount = slotCount;
+ FINISH_TRACE_PACKET();
+}
+
+// State object functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateViewportState(
+ XGL_DEVICE device,
+ const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
+ XGL_VIEWPORT_STATE_OBJECT* pState)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateViewportState* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateViewportState);
+ CREATE_TRACE_PACKET(xglCreateViewportState, sizeof(XGL_VIEWPORT_STATE_CREATE_INFO) + sizeof(XGL_VIEWPORT_STATE_OBJECT));
+ result = real_xglCreateViewportState(device, pCreateInfo, pState);
+ pPacket = interpret_body_as_xglCreateViewportState(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_VIEWPORT_STATE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(XGL_VIEWPORT_STATE_OBJECT), pState);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateRasterState(
+ XGL_DEVICE device,
+ const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
+ XGL_RASTER_STATE_OBJECT* pState)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateRasterState* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateRasterState);
+ CREATE_TRACE_PACKET(xglCreateRasterState, sizeof(XGL_RASTER_STATE_CREATE_INFO) + sizeof(XGL_RASTER_STATE_OBJECT));
+ result = real_xglCreateRasterState(device, pCreateInfo, pState);
+ pPacket = interpret_body_as_xglCreateRasterState(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_RASTER_STATE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(XGL_RASTER_STATE_OBJECT), pState);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateMsaaState(
+ XGL_DEVICE device,
+ const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
+ XGL_MSAA_STATE_OBJECT* pState)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateMsaaState* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateMsaaState);
+ CREATE_TRACE_PACKET(xglCreateMsaaState, sizeof(XGL_MSAA_STATE_CREATE_INFO) + sizeof(XGL_MSAA_STATE_OBJECT));
+ result = real_xglCreateMsaaState(device, pCreateInfo, pState);
+ pPacket = interpret_body_as_xglCreateMsaaState(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_MSAA_STATE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(XGL_MSAA_STATE_OBJECT), pState);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateColorBlendState(
+ XGL_DEVICE device,
+ const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_BLEND_STATE_OBJECT* pState)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateColorBlendState* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateColorBlendState);
+ CREATE_TRACE_PACKET(xglCreateColorBlendState, sizeof(XGL_COLOR_BLEND_STATE_CREATE_INFO) + sizeof(XGL_COLOR_BLEND_STATE_OBJECT));
+ result = real_xglCreateColorBlendState(device, pCreateInfo, pState);
+ pPacket = interpret_body_as_xglCreateColorBlendState(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_COLOR_BLEND_STATE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(XGL_COLOR_BLEND_STATE_OBJECT), pState);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateDepthStencilState(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_STATE_OBJECT* pState)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateDepthStencilState* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateDepthStencilState);
+ CREATE_TRACE_PACKET(xglCreateDepthStencilState, sizeof(XGL_DEPTH_STENCIL_STATE_CREATE_INFO) + sizeof(XGL_DEPTH_STENCIL_STATE_OBJECT));
+ result = real_xglCreateDepthStencilState(device, pCreateInfo, pState);
+ pPacket = interpret_body_as_xglCreateDepthStencilState(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_DEPTH_STENCIL_STATE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pState), sizeof(XGL_DEPTH_STENCIL_STATE_OBJECT), pState);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pState));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+// Command buffer functions
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglCreateCommandBuffer(
+ XGL_DEVICE device,
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_CMD_BUFFER* pCmdBuffer)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglCreateCommandBuffer* pPacket;
+ SEND_ENTRYPOINT_ID(xglCreateCommandBuffer);
+ CREATE_TRACE_PACKET(xglCreateCommandBuffer, sizeof(XGL_CMD_BUFFER_CREATE_INFO) + sizeof(XGL_CMD_BUFFER));
+ result = real_xglCreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ pPacket = interpret_body_as_xglCreateCommandBuffer(pHeader);
+ pPacket->device = device;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_CMD_BUFFER_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCmdBuffer), sizeof(XGL_CMD_BUFFER), pCmdBuffer);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCmdBuffer));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglBeginCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_FLAGS flags)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglBeginCommandBuffer* pPacket;
+ SEND_ENTRYPOINT_ID(xglBeginCommandBuffer);
+ CREATE_TRACE_PACKET(xglBeginCommandBuffer, 0);
+ result = real_xglBeginCommandBuffer(cmdBuffer, flags);
+ pPacket = interpret_body_as_xglBeginCommandBuffer(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->flags = flags;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglEndCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglEndCommandBuffer* pPacket;
+ SEND_ENTRYPOINT_ID(xglEndCommandBuffer);
+ CREATE_TRACE_PACKET(xglEndCommandBuffer, 0);
+ result = real_xglEndCommandBuffer(cmdBuffer);
+ pPacket = interpret_body_as_xglEndCommandBuffer(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglResetCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglResetCommandBuffer* pPacket;
+ SEND_ENTRYPOINT_ID(xglResetCommandBuffer);
+ CREATE_TRACE_PACKET(xglResetCommandBuffer, 0);
+ result = real_xglResetCommandBuffer(cmdBuffer);
+ pPacket = interpret_body_as_xglResetCommandBuffer(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->result = result;
+ return result;
+}
+
+// Command buffer building functions
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindPipeline(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE pipeline)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindPipeline* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindPipeline);
+ CREATE_TRACE_PACKET(xglCmdBindPipeline, 0);
+ real_xglCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ pPacket = interpret_body_as_xglCmdBindPipeline(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ pPacket->pipeline = pipeline;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindPipelineDelta(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE_DELTA delta)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindPipelineDelta* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindPipelineDelta);
+ CREATE_TRACE_PACKET(xglCmdBindPipelineDelta, 0);
+ real_xglCmdBindPipelineDelta(cmdBuffer, pipelineBindPoint, delta);
+ pPacket = interpret_body_as_xglCmdBindPipelineDelta(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ pPacket->delta = delta;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindStateObject(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_STATE_BIND_POINT stateBindPoint,
+ XGL_STATE_OBJECT state)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindStateObject* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindStateObject);
+ CREATE_TRACE_PACKET(xglCmdBindStateObject, 0);
+ real_xglCmdBindStateObject(cmdBuffer, stateBindPoint, state);
+ pPacket = interpret_body_as_xglCmdBindStateObject(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->stateBindPoint = stateBindPoint;
+ pPacket->state = state;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindDescriptorSet(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT index,
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT slotOffset)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindDescriptorSet* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindDescriptorSet);
+ CREATE_TRACE_PACKET(xglCmdBindDescriptorSet, 0);
+ real_xglCmdBindDescriptorSet(cmdBuffer, pipelineBindPoint, index, descriptorSet, slotOffset);
+ pPacket = interpret_body_as_xglCmdBindDescriptorSet(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ pPacket->index = index;
+ pPacket->descriptorSet = descriptorSet;
+ pPacket->slotOffset = slotOffset;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindDynamicMemoryView(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindDynamicMemoryView* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindDynamicMemoryView);
+ CREATE_TRACE_PACKET(xglCmdBindDynamicMemoryView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));
+ real_xglCmdBindDynamicMemoryView(cmdBuffer, pipelineBindPoint, pMemView);
+ pPacket = interpret_body_as_xglCmdBindDynamicMemoryView(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMemView), sizeof(XGL_MEMORY_VIEW_ATTACH_INFO), pMemView);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMemView));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindIndexData(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_INDEX_TYPE indexType)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindIndexData* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindIndexData);
+ CREATE_TRACE_PACKET(xglCmdBindIndexData, 0);
+ real_xglCmdBindIndexData(cmdBuffer, mem, offset, indexType);
+ pPacket = interpret_body_as_xglCmdBindIndexData(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->mem = mem;
+ pPacket->offset = offset;
+ pPacket->indexType = indexType;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBindAttachments(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT colorAttachmentCount,
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments,
+ const XGL_DEPTH_STENCIL_BIND_INFO* pDepthAttachment)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBindAttachments* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBindAttachments);
+ CREATE_TRACE_PACKET(xglCmdBindAttachments, colorAttachmentCount*sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO)+((pDepthAttachment != NULL) ? sizeof(XGL_DEPTH_STENCIL_BIND_INFO) : 0));
+ real_xglCmdBindAttachments(cmdBuffer, colorAttachmentCount, pColorAttachments, pDepthAttachment);
+ pPacket = interpret_body_as_xglCmdBindAttachments(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->colorAttachmentCount = colorAttachmentCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pColorAttachments), colorAttachmentCount*sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO), pColorAttachments);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDepthAttachment), sizeof(XGL_DEPTH_STENCIL_BIND_INFO), pDepthAttachment);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pColorAttachments));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pDepthAttachment));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdPrepareMemoryRegions(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_MEMORY_STATE_TRANSITION* pStateTransitions)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdPrepareMemoryRegions* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdPrepareMemoryRegions);
+ CREATE_TRACE_PACKET(xglCmdPrepareMemoryRegions, transitionCount*sizeof(XGL_MEMORY_STATE_TRANSITION));
+ real_xglCmdPrepareMemoryRegions(cmdBuffer, transitionCount, pStateTransitions);
+ pPacket = interpret_body_as_xglCmdPrepareMemoryRegions(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->transitionCount = transitionCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pStateTransitions), transitionCount*sizeof(XGL_MEMORY_STATE_TRANSITION), pStateTransitions);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pStateTransitions));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdPrepareImages(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_IMAGE_STATE_TRANSITION* pStateTransitions)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdPrepareImages* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdPrepareImages);
+ CREATE_TRACE_PACKET(xglCmdPrepareImages, transitionCount*sizeof(XGL_IMAGE_STATE_TRANSITION));
+ real_xglCmdPrepareImages(cmdBuffer, transitionCount, pStateTransitions);
+ pPacket = interpret_body_as_xglCmdPrepareImages(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->transitionCount = transitionCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pStateTransitions), transitionCount*sizeof(XGL_IMAGE_STATE_TRANSITION), pStateTransitions);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pStateTransitions));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDraw(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstVertex,
+ XGL_UINT vertexCount,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDraw* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDraw);
+ CREATE_TRACE_PACKET(xglCmdDraw, 0);
+ real_xglCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+ pPacket = interpret_body_as_xglCmdDraw(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->firstVertex = firstVertex;
+ pPacket->vertexCount = vertexCount;
+ pPacket->firstInstance = firstInstance;
+ pPacket->instanceCount = instanceCount;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDrawIndexed(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstIndex,
+ XGL_UINT indexCount,
+ XGL_INT vertexOffset,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDrawIndexed* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDrawIndexed);
+ CREATE_TRACE_PACKET(xglCmdDrawIndexed, 0);
+ real_xglCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+ pPacket = interpret_body_as_xglCmdDrawIndexed(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->firstIndex = firstIndex;
+ pPacket->indexCount = indexCount;
+ pPacket->vertexOffset = vertexOffset;
+ pPacket->firstInstance = firstInstance;
+ pPacket->instanceCount = instanceCount;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDrawIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDrawIndirect* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDrawIndirect);
+ CREATE_TRACE_PACKET(xglCmdDrawIndirect, 0);
+ real_xglCmdDrawIndirect(cmdBuffer, mem, offset, count, stride);
+ pPacket = interpret_body_as_xglCmdDrawIndirect(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->mem = mem;
+ pPacket->offset = offset;
+ pPacket->count = count;
+ pPacket->stride = stride;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDrawIndexedIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDrawIndexedIndirect* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDrawIndexedIndirect);
+ CREATE_TRACE_PACKET(xglCmdDrawIndexedIndirect, 0);
+ real_xglCmdDrawIndexedIndirect(cmdBuffer, mem, offset, count, stride);
+ pPacket = interpret_body_as_xglCmdDrawIndexedIndirect(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->mem = mem;
+ pPacket->offset = offset;
+ pPacket->count = count;
+ pPacket->stride = stride;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDispatch(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT x,
+ XGL_UINT y,
+ XGL_UINT z)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDispatch* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDispatch);
+ CREATE_TRACE_PACKET(xglCmdDispatch, 0);
+ real_xglCmdDispatch(cmdBuffer, x, y, z);
+ pPacket = interpret_body_as_xglCmdDispatch(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->x = x;
+ pPacket->y = y;
+ pPacket->z = z;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDispatchIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDispatchIndirect* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDispatchIndirect);
+ CREATE_TRACE_PACKET(xglCmdDispatchIndirect, 0);
+ real_xglCmdDispatchIndirect(cmdBuffer, mem, offset);
+ pPacket = interpret_body_as_xglCmdDispatchIndirect(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->mem = mem;
+ pPacket->offset = offset;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdCopyMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_COPY* pRegions)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdCopyMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdCopyMemory);
+ CREATE_TRACE_PACKET(xglCmdCopyMemory, regionCount*sizeof(XGL_MEMORY_COPY));
+ real_xglCmdCopyMemory(cmdBuffer, srcMem, destMem, regionCount, pRegions);
+ pPacket = interpret_body_as_xglCmdCopyMemory(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->srcMem = srcMem;
+ pPacket->destMem = destMem;
+ pPacket->regionCount = regionCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRegions), regionCount*sizeof(XGL_MEMORY_COPY), pRegions);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRegions));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdCopyImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_IMAGE_COPY* pRegions)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdCopyImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdCopyImage);
+ CREATE_TRACE_PACKET(xglCmdCopyImage, regionCount*sizeof(XGL_MEMORY_IMAGE_COPY));
+ real_xglCmdCopyImage(cmdBuffer, srcImage, destImage, regionCount, pRegions);
+ pPacket = interpret_body_as_xglCmdCopyImage(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->srcImage = srcImage;
+ pPacket->destImage = destImage;
+ pPacket->regionCount = regionCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRegions), regionCount*sizeof(XGL_MEMORY_IMAGE_COPY), pRegions);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRegions)); FINISH_TRACE_PACKET();
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdCopyMemoryToImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdCopyMemoryToImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdCopyMemoryToImage);
+ CREATE_TRACE_PACKET(xglCmdCopyMemoryToImage, regionCount*sizeof(XGL_MEMORY_IMAGE_COPY));
+ real_xglCmdCopyMemoryToImage(cmdBuffer, srcMem, destImage, regionCount, pRegions);
+ pPacket = interpret_body_as_xglCmdCopyMemoryToImage(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->srcMem = srcMem;
+ pPacket->destImage = destImage;
+ pPacket->regionCount = regionCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRegions), regionCount*sizeof(XGL_MEMORY_IMAGE_COPY), pRegions);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRegions));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdCopyImageToMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdCopyImageToMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdCopyImageToMemory);
+ CREATE_TRACE_PACKET(xglCmdCopyImageToMemory, regionCount*sizeof(XGL_MEMORY_IMAGE_COPY));
+ real_xglCmdCopyImageToMemory(cmdBuffer, srcImage, destMem, regionCount, pRegions);
+ pPacket = interpret_body_as_xglCmdCopyImageToMemory(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->srcImage = srcImage;
+ pPacket->destMem = destMem;
+ pPacket->regionCount = regionCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRegions), regionCount*sizeof(XGL_MEMORY_IMAGE_COPY), pRegions);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRegions));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdCloneImageData(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE_STATE srcImageState,
+ XGL_IMAGE destImage,
+ XGL_IMAGE_STATE destImageState)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdCloneImageData* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdCloneImageData);
+ CREATE_TRACE_PACKET(xglCmdCloneImageData, 0);
+ real_xglCmdCloneImageData(cmdBuffer, srcImage, srcImageState, destImage, destImageState);
+ pPacket = interpret_body_as_xglCmdCloneImageData(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->srcImage = srcImage;
+ pPacket->srcImageState = srcImageState;
+ pPacket->destImage = destImage;
+ pPacket->destImageState = destImageState;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdUpdateMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE dataSize,
+ const XGL_UINT32* pData)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdUpdateMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdUpdateMemory);
+ CREATE_TRACE_PACKET(xglCmdUpdateMemory, dataSize);
+ real_xglCmdUpdateMemory(cmdBuffer, destMem, destOffset, dataSize, pData);
+ pPacket = interpret_body_as_xglCmdUpdateMemory(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->destMem = destMem;
+ pPacket->destOffset = destOffset;
+ pPacket->dataSize = dataSize;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), dataSize, pData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdFillMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE fillSize,
+ XGL_UINT32 data)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdFillMemory* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdFillMemory);
+ CREATE_TRACE_PACKET(xglCmdFillMemory, 0);
+ real_xglCmdFillMemory(cmdBuffer, destMem, destOffset, fillSize, data);
+ pPacket = interpret_body_as_xglCmdFillMemory(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->destMem = destMem;
+ pPacket->destOffset = destOffset;
+ pPacket->fillSize = fillSize;
+ pPacket->data = data;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdClearColorImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_FLOAT color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdClearColorImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdClearColorImage);
+ CREATE_TRACE_PACKET(xglCmdClearColorImage, rangeCount*sizeof(XGL_IMAGE_SUBRESOURCE_RANGE));
+ real_xglCmdClearColorImage(cmdBuffer, image, color, rangeCount, pRanges);
+ pPacket = interpret_body_as_xglCmdClearColorImage(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->image = image;
+ memcpy((void*)pPacket->color, color, 4 * sizeof(XGL_UINT32));
+ pPacket->rangeCount = rangeCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRanges), rangeCount*sizeof(XGL_IMAGE_SUBRESOURCE_RANGE), pRanges);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRanges));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdClearColorImageRaw(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_UINT32 color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdClearColorImageRaw* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdClearColorImageRaw);
+ CREATE_TRACE_PACKET(xglCmdClearColorImageRaw, rangeCount*sizeof(XGL_IMAGE_SUBRESOURCE_RANGE));
+ real_xglCmdClearColorImageRaw(cmdBuffer, image, color, rangeCount, pRanges);
+ pPacket = interpret_body_as_xglCmdClearColorImageRaw(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->image = image;
+ memcpy((void*)pPacket->color, color, 4 * sizeof(XGL_UINT32));
+ pPacket->rangeCount = rangeCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRanges), rangeCount*sizeof(XGL_IMAGE_SUBRESOURCE_RANGE), pRanges);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRanges));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdClearDepthStencil(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ XGL_FLOAT depth,
+ XGL_UINT32 stencil,
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdClearDepthStencil* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdClearDepthStencil);
+ CREATE_TRACE_PACKET(xglCmdClearDepthStencil, rangeCount*sizeof(XGL_IMAGE_SUBRESOURCE_RANGE));
+ real_xglCmdClearDepthStencil(cmdBuffer, image, depth, stencil, rangeCount, pRanges);
+ pPacket = interpret_body_as_xglCmdClearDepthStencil(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->image = image;
+ pPacket->depth = depth;
+ pPacket->stencil = stencil;
+ pPacket->rangeCount = rangeCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRanges), rangeCount*sizeof(XGL_IMAGE_SUBRESOURCE_RANGE), pRanges);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRanges));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdResolveImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT rectCount,
+ const XGL_IMAGE_RESOLVE* pRects)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdResolveImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdResolveImage);
+ CREATE_TRACE_PACKET(xglCmdResolveImage, rectCount*sizeof(XGL_IMAGE_RESOLVE));
+ real_xglCmdResolveImage(cmdBuffer, srcImage, destImage, rectCount, pRects);
+ pPacket = interpret_body_as_xglCmdResolveImage(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->srcImage = srcImage;
+ pPacket->destImage = destImage;
+ pPacket->rectCount = rectCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRects), rectCount*sizeof(XGL_IMAGE_RESOLVE), pRects);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pRects));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdSetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdSetEvent* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdSetEvent);
+ CREATE_TRACE_PACKET(xglCmdSetEvent, 0);
+ real_xglCmdSetEvent(cmdBuffer, event);
+ pPacket = interpret_body_as_xglCmdSetEvent(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->event = event;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdResetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdResetEvent* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdResetEvent);
+ CREATE_TRACE_PACKET(xglCmdResetEvent, 0);
+ real_xglCmdResetEvent(cmdBuffer, event);
+ pPacket = interpret_body_as_xglCmdResetEvent(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->event = event;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdMemoryAtomic(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_UINT64 srcData,
+ XGL_ATOMIC_OP atomicOp)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdMemoryAtomic* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdMemoryAtomic);
+ CREATE_TRACE_PACKET(xglCmdMemoryAtomic, 0);
+ real_xglCmdMemoryAtomic(cmdBuffer, destMem, destOffset, srcData, atomicOp);
+ pPacket = interpret_body_as_xglCmdMemoryAtomic(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->destMem = destMem;
+ pPacket->destOffset = destOffset;
+ pPacket->srcData = srcData;
+ pPacket->atomicOp = atomicOp;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdBeginQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot,
+ XGL_FLAGS flags)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdBeginQuery* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdBeginQuery);
+ CREATE_TRACE_PACKET(xglCmdBeginQuery, 0);
+ real_xglCmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ pPacket = interpret_body_as_xglCmdBeginQuery(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->queryPool = queryPool;
+ pPacket->slot = slot;
+ pPacket->flags = flags;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdEndQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdEndQuery* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdEndQuery);
+ CREATE_TRACE_PACKET(xglCmdEndQuery, 0);
+ real_xglCmdEndQuery(cmdBuffer, queryPool, slot);
+ pPacket = interpret_body_as_xglCmdEndQuery(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->queryPool = queryPool;
+ pPacket->slot = slot;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdResetQueryPool(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdResetQueryPool* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdResetQueryPool);
+ CREATE_TRACE_PACKET(xglCmdResetQueryPool, 0);
+ real_xglCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ pPacket = interpret_body_as_xglCmdResetQueryPool(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->queryPool = queryPool;
+ pPacket->startQuery = startQuery;
+ pPacket->queryCount = queryCount;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdWriteTimestamp(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_TIMESTAMP_TYPE timestampType,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdWriteTimestamp* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdWriteTimestamp);
+ CREATE_TRACE_PACKET(xglCmdWriteTimestamp, 0);
+ real_xglCmdWriteTimestamp(cmdBuffer, timestampType, destMem, destOffset);
+ pPacket = interpret_body_as_xglCmdWriteTimestamp(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->timestampType = timestampType;
+ pPacket->destMem = destMem;
+ pPacket->destOffset = destOffset;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdInitAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ const XGL_UINT32* pData)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdInitAtomicCounters* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdInitAtomicCounters);
+ CREATE_TRACE_PACKET(xglCmdInitAtomicCounters, counterCount*sizeof(XGL_UINT32));
+ real_xglCmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
+ pPacket = interpret_body_as_xglCmdInitAtomicCounters(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ pPacket->startCounter = startCounter;
+ pPacket->counterCount = counterCount;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), counterCount*sizeof(XGL_UINT32), pData);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdLoadAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_SIZE srcOffset)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdLoadAtomicCounters* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdLoadAtomicCounters);
+ CREATE_TRACE_PACKET(xglCmdLoadAtomicCounters, 0);
+ real_xglCmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcMem, srcOffset);
+ pPacket = interpret_body_as_xglCmdLoadAtomicCounters(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ pPacket->startCounter = startCounter;
+ pPacket->counterCount = counterCount;
+ pPacket->srcMem = srcMem;
+ pPacket->srcOffset = srcOffset;
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdSaveAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdSaveAtomicCounters* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdSaveAtomicCounters);
+ CREATE_TRACE_PACKET(xglCmdSaveAtomicCounters, 0);
+ real_xglCmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destMem, destOffset);
+ pPacket = interpret_body_as_xglCmdSaveAtomicCounters(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ pPacket->pipelineBindPoint = pipelineBindPoint;
+ pPacket->startCounter = startCounter;
+ pPacket->counterCount = counterCount;
+ pPacket->destMem = destMem;
+ pPacket->destOffset = destOffset;
+ FINISH_TRACE_PACKET();
+}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl.h
new file mode 100644
index 0000000..a8eff4d
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl.h
@@ -0,0 +1,826 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glvtrace_xgl_xgl_structs.h"
+#include "glvtrace_xgl_packet_id.h"
+
+void AttachHooks();
+void DetachHooks();
+
+// Pointers to real functions and declarations of hooked functions
+#ifdef WIN32
+#define __HOOKED_xglInitAndEnumerateGpus hooked_xglInitAndEnumerateGpus
+#define __HOOKED_xglGetGpuInfo hooked_xglGetGpuInfo
+#define __HOOKED_xglCreateDevice hooked_xglCreateDevice
+#define __HOOKED_xglDestroyDevice hooked_xglDestroyDevice
+#define __HOOKED_xglGetExtensionSupport hooked_xglGetExtensionSupport
+#define __HOOKED_xglGetDeviceQueue hooked_xglGetDeviceQueue
+#define __HOOKED_xglQueueSubmit hooked_xglQueueSubmit
+#define __HOOKED_xglQueueSetGlobalMemReferences hooked_xglQueueSetGlobalMemReferences
+#define __HOOKED_xglQueueWaitIdle hooked_xglQueueWaitIdle
+#define __HOOKED_xglDeviceWaitIdle hooked_xglDeviceWaitIdle
+#define __HOOKED_xglGetMemoryHeapCount hooked_xglGetMemoryHeapCount
+#define __HOOKED_xglGetMemoryHeapInfo hooked_xglGetMemoryHeapInfo
+#define __HOOKED_xglAllocMemory hooked_xglAllocMemory
+#define __HOOKED_xglFreeMemory hooked_xglFreeMemory
+#define __HOOKED_xglSetMemoryPriority hooked_xglSetMemoryPriority
+#define __HOOKED_xglMapMemory hooked_xglMapMemory
+#define __HOOKED_xglUnmapMemory hooked_xglUnmapMemory
+#define __HOOKED_xglPinSystemMemory hooked_xglPinSystemMemory
+#define __HOOKED_xglRemapVirtualMemoryPages hooked_xglRemapVirtualMemoryPages
+#define __HOOKED_xglGetMultiGpuCompatibility hooked_xglGetMultiGpuCompatibility
+#define __HOOKED_xglOpenSharedMemory hooked_xglOpenSharedMemory
+#define __HOOKED_xglOpenSharedQueueSemaphore hooked_xglOpenSharedQueueSemaphore
+#define __HOOKED_xglOpenPeerMemory hooked_xglOpenPeerMemory
+#define __HOOKED_xglOpenPeerImage hooked_xglOpenPeerImage
+#define __HOOKED_xglDestroyObject hooked_xglDestroyObject
+#define __HOOKED_xglGetObjectInfo hooked_xglGetObjectInfo
+#define __HOOKED_xglBindObjectMemory hooked_xglBindObjectMemory
+#define __HOOKED_xglCreateFence hooked_xglCreateFence
+#define __HOOKED_xglGetFenceStatus hooked_xglGetFenceStatus
+#define __HOOKED_xglWaitForFences hooked_xglWaitForFences
+#define __HOOKED_xglCreateQueueSemaphore hooked_xglCreateQueueSemaphore
+#define __HOOKED_xglSignalQueueSemaphore hooked_xglSignalQueueSemaphore
+#define __HOOKED_xglWaitQueueSemaphore hooked_xglWaitQueueSemaphore
+#define __HOOKED_xglCreateEvent hooked_xglCreateEvent
+#define __HOOKED_xglGetEventStatus hooked_xglGetEventStatus
+#define __HOOKED_xglSetEvent hooked_xglSetEvent
+#define __HOOKED_xglResetEvent hooked_xglResetEvent
+#define __HOOKED_xglCreateQueryPool hooked_xglCreateQueryPool
+#define __HOOKED_xglGetQueryPoolResults hooked_xglGetQueryPoolResults
+#define __HOOKED_xglGetFormatInfo hooked_xglGetFormatInfo
+#define __HOOKED_xglCreateImage hooked_xglCreateImage
+#define __HOOKED_xglGetImageSubresourceInfo hooked_xglGetImageSubresourceInfo
+#define __HOOKED_xglCreateImageView hooked_xglCreateImageView
+#define __HOOKED_xglCreateColorAttachmentView hooked_xglCreateColorAttachmentView
+#define __HOOKED_xglCreateDepthStencilView hooked_xglCreateDepthStencilView
+#define __HOOKED_xglCreateShader hooked_xglCreateShader
+#define __HOOKED_xglCreateGraphicsPipeline hooked_xglCreateGraphicsPipeline
+#define __HOOKED_xglCreateComputePipeline hooked_xglCreateComputePipeline
+#define __HOOKED_xglStorePipeline hooked_xglStorePipeline
+#define __HOOKED_xglLoadPipeline hooked_xglLoadPipeline
+#define __HOOKED_xglCreateSampler hooked_xglCreateSampler
+#define __HOOKED_xglCreateDescriptorSet hooked_xglCreateDescriptorSet
+#define __HOOKED_xglBeginDescriptorSetUpdate hooked_xglBeginDescriptorSetUpdate
+#define __HOOKED_xglEndDescriptorSetUpdate hooked_xglEndDescriptorSetUpdate
+#define __HOOKED_xglAttachSamplerDescriptors hooked_xglAttachSamplerDescriptors
+#define __HOOKED_xglAttachImageViewDescriptors hooked_xglAttachImageViewDescriptors
+#define __HOOKED_xglAttachMemoryViewDescriptors hooked_xglAttachMemoryViewDescriptors
+#define __HOOKED_xglAttachNestedDescriptors hooked_xglAttachNestedDescriptors
+#define __HOOKED_xglClearDescriptorSetSlots hooked_xglClearDescriptorSetSlots
+#define __HOOKED_xglCreateViewportState hooked_xglCreateViewportState
+#define __HOOKED_xglCreateRasterState hooked_xglCreateRasterState
+#define __HOOKED_xglCreateMsaaState hooked_xglCreateMsaaState
+#define __HOOKED_xglCreateColorBlendState hooked_xglCreateColorBlendState
+#define __HOOKED_xglCreateDepthStencilState hooked_xglCreateDepthStencilState
+#define __HOOKED_xglCreateCommandBuffer hooked_xglCreateCommandBuffer
+#define __HOOKED_xglBeginCommandBuffer hooked_xglBeginCommandBuffer
+#define __HOOKED_xglEndCommandBuffer hooked_xglEndCommandBuffer
+#define __HOOKED_xglResetCommandBuffer hooked_xglResetCommandBuffer
+#define __HOOKED_xglCmdBindPipeline hooked_xglCmdBindPipeline
+#define __HOOKED_xglCmdBindStateObject hooked_xglCmdBindStateObject
+#define __HOOKED_xglCmdBindDescriptorSet hooked_xglCmdBindDescriptorSet
+#define __HOOKED_xglCmdBindDynamicMemoryView hooked_xglCmdBindDynamicMemoryView
+#define __HOOKED_xglCmdBindIndexData hooked_xglCmdBindIndexData
+#define __HOOKED_xglCmdBindAttachments hooked_xglCmdBindAttachments
+#define __HOOKED_xglCmdPrepareMemoryRegions hooked_xglCmdPrepareMemoryRegions
+#define __HOOKED_xglCmdPrepareImages hooked_xglCmdPrepareImages
+#define __HOOKED_xglCmdDraw hooked_xglCmdDraw
+#define __HOOKED_xglCmdDrawIndexed hooked_xglCmdDrawIndexed
+#define __HOOKED_xglCmdDrawIndirect hooked_xglCmdDrawIndirect
+#define __HOOKED_xglCmdDrawIndexedIndirect hooked_xglCmdDrawIndexedIndirect
+#define __HOOKED_xglCmdDispatch hooked_xglCmdDispatch
+#define __HOOKED_xglCmdDispatchIndirect hooked_xglCmdDispatchIndirect
+#define __HOOKED_xglCmdCopyMemory hooked_xglCmdCopyMemory
+#define __HOOKED_xglCmdCopyImage hooked_xglCmdCopyImage
+#define __HOOKED_xglCmdCopyMemoryToImage hooked_xglCmdCopyMemoryToImage
+#define __HOOKED_xglCmdCopyImageToMemory hooked_xglCmdCopyImageToMemory
+#define __HOOKED_xglCmdCloneImageData hooked_xglCmdCloneImageData
+#define __HOOKED_xglCmdUpdateMemory hooked_xglCmdUpdateMemory
+#define __HOOKED_xglCmdFillMemory hooked_xglCmdFillMemory
+#define __HOOKED_xglCmdClearColorImage hooked_xglCmdClearColorImage
+#define __HOOKED_xglCmdClearColorImageRaw hooked_xglCmdClearColorImageRaw
+#define __HOOKED_xglCmdClearDepthStencil hooked_xglCmdClearDepthStencil
+#define __HOOKED_xglCmdResolveImage hooked_xglCmdResolveImage
+#define __HOOKED_xglCmdSetEvent hooked_xglCmdSetEvent
+#define __HOOKED_xglCmdResetEvent hooked_xglCmdResetEvent
+#define __HOOKED_xglCmdMemoryAtomic hooked_xglCmdMemoryAtomic
+#define __HOOKED_xglCmdBeginQuery hooked_xglCmdBeginQuery
+#define __HOOKED_xglCmdEndQuery hooked_xglCmdEndQuery
+#define __HOOKED_xglCmdResetQueryPool hooked_xglCmdResetQueryPool
+#define __HOOKED_xglCmdWriteTimestamp hooked_xglCmdWriteTimestamp
+#define __HOOKED_xglCmdInitAtomicCounters hooked_xglCmdInitAtomicCounters
+#define __HOOKED_xglCmdLoadAtomicCounters hooked_xglCmdLoadAtomicCounters
+#define __HOOKED_xglCmdSaveAtomicCounters hooked_xglCmdSaveAtomicCounters
+
+#elif defined(__linux__)
+#define __HOOKED_xglInitAndEnumerateGpus xglInitAndEnumerateGpus
+#define __HOOKED_xglGetGpuInfo xglGetGpuInfo
+#define __HOOKED_xglCreateDevice xglCreateDevice
+#define __HOOKED_xglDestroyDevice xglDestroyDevice
+#define __HOOKED_xglGetExtensionSupport xglGetExtensionSupport
+#define __HOOKED_xglGetDeviceQueue xglGetDeviceQueue
+#define __HOOKED_xglQueueSubmit xglQueueSubmit
+#define __HOOKED_xglQueueSetGlobalMemReferences xglQueueSetGlobalMemReferences
+#define __HOOKED_xglQueueWaitIdle xglQueueWaitIdle
+#define __HOOKED_xglDeviceWaitIdle xglDeviceWaitIdle
+#define __HOOKED_xglGetMemoryHeapCount xglGetMemoryHeapCount
+#define __HOOKED_xglGetMemoryHeapInfo xglGetMemoryHeapInfo
+#define __HOOKED_xglAllocMemory xglAllocMemory
+#define __HOOKED_xglFreeMemory xglFreeMemory
+#define __HOOKED_xglSetMemoryPriority xglSetMemoryPriority
+#define __HOOKED_xglMapMemory xglMapMemory
+#define __HOOKED_xglUnmapMemory xglUnmapMemory
+#define __HOOKED_xglPinSystemMemory xglPinSystemMemory
+#define __HOOKED_xglRemapVirtualMemoryPages xglRemapVirtualMemoryPages
+#define __HOOKED_xglGetMultiGpuCompatibility xglGetMultiGpuCompatibility
+#define __HOOKED_xglOpenSharedMemory xglOpenSharedMemory
+#define __HOOKED_xglOpenSharedQueueSemaphore xglOpenSharedQueueSemaphore
+#define __HOOKED_xglOpenPeerMemory xglOpenPeerMemory
+#define __HOOKED_xglOpenPeerImage xglOpenPeerImage
+#define __HOOKED_xglDestroyObject xglDestroyObject
+#define __HOOKED_xglGetObjectInfo xglGetObjectInfo
+#define __HOOKED_xglBindObjectMemory xglBindObjectMemory
+#define __HOOKED_xglCreateFence xglCreateFence
+#define __HOOKED_xglGetFenceStatus xglGetFenceStatus
+#define __HOOKED_xglWaitForFences xglWaitForFences
+#define __HOOKED_xglCreateQueueSemaphore xglCreateQueueSemaphore
+#define __HOOKED_xglSignalQueueSemaphore xglSignalQueueSemaphore
+#define __HOOKED_xglWaitQueueSemaphore xglWaitQueueSemaphore
+#define __HOOKED_xglCreateEvent xglCreateEvent
+#define __HOOKED_xglGetEventStatus xglGetEventStatus
+#define __HOOKED_xglSetEvent xglSetEvent
+#define __HOOKED_xglResetEvent xglResetEvent
+#define __HOOKED_xglCreateQueryPool xglCreateQueryPool
+#define __HOOKED_xglGetQueryPoolResults xglGetQueryPoolResults
+#define __HOOKED_xglGetFormatInfo xglGetFormatInfo
+#define __HOOKED_xglCreateImage xglCreateImage
+#define __HOOKED_xglGetImageSubresourceInfo xglGetImageSubresourceInfo
+#define __HOOKED_xglCreateImageView xglCreateImageView
+#define __HOOKED_xglCreateColorAttachmentView xglCreateColorAttachmentView
+#define __HOOKED_xglCreateDepthStencilView xglCreateDepthStencilView
+#define __HOOKED_xglCreateShader xglCreateShader
+#define __HOOKED_xglCreateGraphicsPipeline xglCreateGraphicsPipeline
+#define __HOOKED_xglCreateComputePipeline xglCreateComputePipeline
+#define __HOOKED_xglStorePipeline xglStorePipeline
+#define __HOOKED_xglLoadPipeline xglLoadPipeline
+#define __HOOKED_xglCreateSampler xglCreateSampler
+#define __HOOKED_xglCreateDescriptorSet xglCreateDescriptorSet
+#define __HOOKED_xglBeginDescriptorSetUpdate xglBeginDescriptorSetUpdate
+#define __HOOKED_xglEndDescriptorSetUpdate xglEndDescriptorSetUpdate
+#define __HOOKED_xglAttachSamplerDescriptors xglAttachSamplerDescriptors
+#define __HOOKED_xglAttachImageViewDescriptors xglAttachImageViewDescriptors
+#define __HOOKED_xglAttachMemoryViewDescriptors xglAttachMemoryViewDescriptors
+#define __HOOKED_xglAttachNestedDescriptors xglAttachNestedDescriptors
+#define __HOOKED_xglClearDescriptorSetSlots xglClearDescriptorSetSlots
+#define __HOOKED_xglCreateViewportState xglCreateViewportState
+#define __HOOKED_xglCreateRasterState xglCreateRasterState
+#define __HOOKED_xglCreateMsaaState xglCreateMsaaState
+#define __HOOKED_xglCreateColorBlendState xglCreateColorBlendState
+#define __HOOKED_xglCreateDepthStencilState xglCreateDepthStencilState
+#define __HOOKED_xglCreateCommandBuffer xglCreateCommandBuffer
+#define __HOOKED_xglBeginCommandBuffer xglBeginCommandBuffer
+#define __HOOKED_xglEndCommandBuffer xglEndCommandBuffer
+#define __HOOKED_xglResetCommandBuffer xglResetCommandBuffer
+#define __HOOKED_xglCmdBindPipeline xglCmdBindPipeline
+#define __HOOKED_xglCmdBindStateObject xglCmdBindStateObject
+#define __HOOKED_xglCmdBindDescriptorSet xglCmdBindDescriptorSet
+#define __HOOKED_xglCmdBindDynamicMemoryView xglCmdBindDynamicMemoryView
+#define __HOOKED_xglCmdBindIndexData xglCmdBindIndexData
+#define __HOOKED_xglCmdBindAttachments xglCmdBindAttachments
+#define __HOOKED_xglCmdPrepareMemoryRegions xglCmdPrepareMemoryRegions
+#define __HOOKED_xglCmdPrepareImages xglCmdPrepareImages
+#define __HOOKED_xglCmdDraw xglCmdDraw
+#define __HOOKED_xglCmdDrawIndexed xglCmdDrawIndexed
+#define __HOOKED_xglCmdDrawIndirect xglCmdDrawIndirect
+#define __HOOKED_xglCmdDrawIndexedIndirect xglCmdDrawIndexedIndirect
+#define __HOOKED_xglCmdDispatch xglCmdDispatch
+#define __HOOKED_xglCmdDispatchIndirect xglCmdDispatchIndirect
+#define __HOOKED_xglCmdCopyMemory xglCmdCopyMemory
+#define __HOOKED_xglCmdCopyImage xglCmdCopyImage
+#define __HOOKED_xglCmdCopyMemoryToImage xglCmdCopyMemoryToImage
+#define __HOOKED_xglCmdCopyImageToMemory xglCmdCopyImageToMemory
+#define __HOOKED_xglCmdCloneImageData xglCmdCloneImageData
+#define __HOOKED_xglCmdUpdateMemory xglCmdUpdateMemory
+#define __HOOKED_xglCmdFillMemory xglCmdFillMemory
+#define __HOOKED_xglCmdClearColorImage xglCmdClearColorImage
+#define __HOOKED_xglCmdClearColorImageRaw xglCmdClearColorImageRaw
+#define __HOOKED_xglCmdClearDepthStencil xglCmdClearDepthStencil
+#define __HOOKED_xglCmdResolveImage xglCmdResolveImage
+#define __HOOKED_xglCmdSetEvent xglCmdSetEvent
+#define __HOOKED_xglCmdResetEvent xglCmdResetEvent
+#define __HOOKED_xglCmdMemoryAtomic xglCmdMemoryAtomic
+#define __HOOKED_xglCmdBeginQuery xglCmdBeginQuery
+#define __HOOKED_xglCmdEndQuery xglCmdEndQuery
+#define __HOOKED_xglCmdResetQueryPool xglCmdResetQueryPool
+#define __HOOKED_xglCmdWriteTimestamp xglCmdWriteTimestamp
+#define __HOOKED_xglCmdInitAtomicCounters xglCmdInitAtomicCounters
+#define __HOOKED_xglCmdLoadAtomicCounters xglCmdLoadAtomicCounters
+#define __HOOKED_xglCmdSaveAtomicCounters xglCmdSaveAtomicCounters
+#endif
+
+// GPU initialization
+
+XGL_RESULT XGLAPI __HOOKED_xglInitAndEnumerateGpus(
+ const XGL_APPLICATION_INFO* pAppInfo,
+ const XGL_ALLOC_CALLBACKS* pAllocCb,
+ XGL_UINT maxGpus,
+ XGL_UINT* pGpuCount,
+ XGL_PHYSICAL_GPU* pGpus);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetGpuInfo(
+ XGL_PHYSICAL_GPU gpu,
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+// Device functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateDevice(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo,
+ XGL_DEVICE* pDevice);
+
+XGL_RESULT XGLAPI __HOOKED_xglDestroyDevice(
+ XGL_DEVICE device);
+
+// Extension discovery functions
+XGL_RESULT XGLAPI __HOOKED_xglGetExtensionSupport(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_CHAR* pExtName);
+
+// Queue functions
+
+XGL_RESULT XGLAPI __HOOKED_xglGetDeviceQueue(
+ XGL_DEVICE device,
+ XGL_QUEUE_TYPE queueType,
+ XGL_UINT queueIndex,
+ XGL_QUEUE* pQueue);
+
+XGL_RESULT XGLAPI __HOOKED_xglQueueSubmit(
+ XGL_QUEUE queue,
+ XGL_UINT cmdBufferCount,
+ const XGL_CMD_BUFFER* pCmdBuffers,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs,
+ XGL_FENCE fence);
+
+XGL_RESULT XGLAPI __HOOKED_xglQueueSetGlobalMemReferences(
+ XGL_QUEUE queue,
+ XGL_UINT memRefCount,
+ const XGL_MEMORY_REF* pMemRefs);
+
+XGL_RESULT XGLAPI __HOOKED_xglQueueWaitIdle(
+ XGL_QUEUE queue);
+
+XGL_RESULT XGLAPI __HOOKED_xglDeviceWaitIdle(
+ XGL_DEVICE device);
+
+// Memory functions
+XGL_RESULT XGLAPI __HOOKED_xglGetMemoryHeapCount(
+ XGL_DEVICE device,
+ XGL_UINT* pCount);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetMemoryHeapInfo(
+ XGL_DEVICE device,
+ XGL_UINT heapId,
+ XGL_MEMORY_HEAP_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+XGL_RESULT XGLAPI __HOOKED_xglAllocMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
+ XGL_GPU_MEMORY* pMem);
+
+XGL_RESULT XGLAPI __HOOKED_xglFreeMemory(
+ XGL_GPU_MEMORY mem);
+
+XGL_RESULT XGLAPI __HOOKED_xglSetMemoryPriority(
+ XGL_GPU_MEMORY mem,
+ XGL_MEMORY_PRIORITY priority);
+
+XGL_RESULT XGLAPI __HOOKED_xglMapMemory(
+ XGL_GPU_MEMORY mem,
+ XGL_FLAGS flags, // Reserved
+ XGL_VOID** ppData);
+
+XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(
+ XGL_GPU_MEMORY mem);
+
+XGL_RESULT XGLAPI __HOOKED_xglPinSystemMemory(
+ XGL_DEVICE device,
+ const XGL_VOID* pSysMem,
+ XGL_SIZE memSize,
+ XGL_GPU_MEMORY* pMem);
+
+XGL_RESULT XGLAPI __HOOKED_xglRemapVirtualMemoryPages(
+ XGL_DEVICE device,
+ XGL_UINT rangeCount,
+ const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
+ XGL_UINT preWaitSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
+ XGL_UINT postSignalSemaphoreCount,
+ const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
+
+// Multi-device functions
+XGL_RESULT XGLAPI __HOOKED_xglGetMultiGpuCompatibility(
+ XGL_PHYSICAL_GPU gpu0,
+ XGL_PHYSICAL_GPU gpu1,
+ XGL_GPU_COMPATIBILITY_INFO* pInfo);
+
+XGL_RESULT XGLAPI __HOOKED_xglOpenSharedMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem);
+
+XGL_RESULT XGLAPI __HOOKED_xglOpenSharedQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore);
+
+XGL_RESULT XGLAPI __HOOKED_xglOpenPeerMemory(
+ XGL_DEVICE device,
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem);
+
+XGL_RESULT XGLAPI __HOOKED_xglOpenPeerImage(
+ XGL_DEVICE device,
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem);
+
+// Generic API object functions
+
+XGL_RESULT XGLAPI __HOOKED_xglDestroyObject(
+ XGL_OBJECT object);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetObjectInfo(
+ XGL_BASE_OBJECT object,
+ XGL_OBJECT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+XGL_RESULT XGLAPI __HOOKED_xglBindObjectMemory(
+ XGL_OBJECT object,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset);
+
+// Fence functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateFence(
+ XGL_DEVICE device,
+ const XGL_FENCE_CREATE_INFO* pCreateInfo,
+ XGL_FENCE* pFence);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetFenceStatus(
+ XGL_FENCE fence);
+
+XGL_RESULT XGLAPI __HOOKED_xglWaitForFences(
+ XGL_DEVICE device,
+ XGL_UINT fenceCount,
+ const XGL_FENCE* pFences,
+ XGL_BOOL waitAll,
+ XGL_UINT64 timeout);
+
+// Queue semaphore functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore);
+
+XGL_RESULT XGLAPI __HOOKED_xglSignalQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore);
+
+XGL_RESULT XGLAPI __HOOKED_xglWaitQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore);
+
+// Event functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateEvent(
+ XGL_DEVICE device,
+ const XGL_EVENT_CREATE_INFO* pCreateInfo,
+ XGL_EVENT* pEvent);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetEventStatus(
+ XGL_EVENT event);
+
+XGL_RESULT XGLAPI __HOOKED_xglSetEvent(
+ XGL_EVENT event);
+
+XGL_RESULT XGLAPI __HOOKED_xglResetEvent(
+ XGL_EVENT event);
+
+// Query functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateQueryPool(
+ XGL_DEVICE device,
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ XGL_QUERY_POOL* pQueryPool);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetQueryPoolResults(
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+// Format capabilities
+
+XGL_RESULT XGLAPI __HOOKED_xglGetFormatInfo(
+ XGL_DEVICE device,
+ XGL_FORMAT format,
+ XGL_FORMAT_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+// Image functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateImage(
+ XGL_DEVICE device,
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage);
+
+XGL_RESULT XGLAPI __HOOKED_xglGetImageSubresourceInfo(
+ XGL_IMAGE image,
+ const XGL_IMAGE_SUBRESOURCE* pSubresource,
+ XGL_SUBRESOURCE_INFO_TYPE infoType,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+// Image view functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateImageView(
+ XGL_DEVICE device,
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE_VIEW* pView);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateColorAttachmentView(
+ XGL_DEVICE device,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_ATTACHMENT_VIEW* pView);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateDepthStencilView(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_VIEW* pView);
+
+// Shader functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateShader(
+ XGL_DEVICE device,
+ const XGL_SHADER_CREATE_INFO* pCreateInfo,
+ XGL_SHADER* pShader);
+
+// Pipeline functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateGraphicsPipeline(
+ XGL_DEVICE device,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateComputePipeline(
+ XGL_DEVICE device,
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline);
+
+XGL_RESULT XGLAPI __HOOKED_xglStorePipeline(
+ XGL_PIPELINE pipeline,
+ XGL_SIZE* pDataSize,
+ XGL_VOID* pData);
+
+XGL_RESULT XGLAPI __HOOKED_xglLoadPipeline(
+ XGL_DEVICE device,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData,
+ XGL_PIPELINE* pPipeline);
+
+// Sampler functions
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateSampler(
+ XGL_DEVICE device,
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
+ XGL_SAMPLER* pSampler);
+
+// Descriptor set functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateDescriptorSet(
+ XGL_DEVICE device,
+ const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_SET* pDescriptorSet);
+
+XGL_VOID XGLAPI __HOOKED_xglBeginDescriptorSetUpdate(
+ XGL_DESCRIPTOR_SET descriptorSet);
+
+XGL_VOID XGLAPI __HOOKED_xglEndDescriptorSetUpdate(
+ XGL_DESCRIPTOR_SET descriptorSet);
+
+XGL_VOID XGLAPI __HOOKED_xglAttachSamplerDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_SAMPLER* pSamplers);
+
+XGL_VOID XGLAPI __HOOKED_xglAttachImageViewDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
+
+XGL_VOID XGLAPI __HOOKED_xglAttachMemoryViewDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
+
+XGL_VOID XGLAPI __HOOKED_xglAttachNestedDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount,
+ const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
+
+XGL_VOID XGLAPI __HOOKED_xglClearDescriptorSetSlots(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT startSlot,
+ XGL_UINT slotCount);
+
+// State object functions
+XGL_RESULT XGLAPI __HOOKED_xglCreateViewportState(
+ XGL_DEVICE device,
+ const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
+ XGL_VIEWPORT_STATE_OBJECT* pState);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateRasterState(
+ XGL_DEVICE device,
+ const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
+ XGL_RASTER_STATE_OBJECT* pState);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateMsaaState(
+ XGL_DEVICE device,
+ const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
+ XGL_MSAA_STATE_OBJECT* pState);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateColorBlendState(
+ XGL_DEVICE device,
+ const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_BLEND_STATE_OBJECT* pState);
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateDepthStencilState(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+
+// Command buffer functions
+
+XGL_RESULT XGLAPI __HOOKED_xglCreateCommandBuffer(
+ XGL_DEVICE device,
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_CMD_BUFFER* pCmdBuffer);
+
+XGL_RESULT XGLAPI __HOOKED_xglBeginCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_FLAGS flags); // XGL_CMD_BUFFER_BUILD_FLAGS
+
+XGL_RESULT XGLAPI __HOOKED_xglEndCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer);
+
+XGL_RESULT XGLAPI __HOOKED_xglResetCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer);
+
+// Command buffer building functions
+XGL_VOID XGLAPI __HOOKED_xglCmdBindPipeline(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE pipeline);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdBindStateObject(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_STATE_BIND_POINT stateBindPoint,
+ XGL_STATE_OBJECT state);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdBindDescriptorSet(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT index,
+ XGL_DESCRIPTOR_SET descriptorSet,
+ XGL_UINT slotOffset);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdBindDynamicMemoryView(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdBindIndexData(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_INDEX_TYPE indexType);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdBindAttachments(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT colorTargetCount,
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorTargets,
+ const XGL_DEPTH_STENCIL_BIND_INFO* pDepthTarget);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdPrepareMemoryRegions(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdPrepareImages(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT transitionCount,
+ const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDraw(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstVertex,
+ XGL_UINT vertexCount,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDrawIndexed(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT firstIndex,
+ XGL_UINT indexCount,
+ XGL_INT vertexOffset,
+ XGL_UINT firstInstance,
+ XGL_UINT instanceCount);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDrawIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDrawIndexedIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset,
+ XGL_UINT32 count,
+ XGL_UINT32 stride);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDispatch(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_UINT x,
+ XGL_UINT y,
+ XGL_UINT z);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDispatchIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE offset);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdCopyMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_COPY* pRegions);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdCopyImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_IMAGE_COPY* pRegions);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdCopyMemoryToImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY srcMem,
+ XGL_IMAGE destImage,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdCopyImageToMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_GPU_MEMORY destMem,
+ XGL_UINT regionCount,
+ const XGL_MEMORY_IMAGE_COPY* pRegions);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdCloneImageData(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE_STATE srcImageState,
+ XGL_IMAGE destImage,
+ XGL_IMAGE_STATE destImageState);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdUpdateMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE dataSize,
+ const XGL_UINT32* pData);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdFillMemory(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE fillSize,
+ XGL_UINT32 data);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdClearColorImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_FLOAT color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdClearColorImageRaw(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const XGL_UINT32 color[4],
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdClearDepthStencil(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ XGL_FLOAT depth,
+ XGL_UINT32 stencil,
+ XGL_UINT rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdResolveImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ XGL_UINT rectCount,
+ const XGL_IMAGE_RESOLVE* pRects);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdSetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdResetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdMemoryAtomic(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset,
+ XGL_UINT64 srcData,
+ XGL_ATOMIC_OP atomicOp);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdBeginQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot,
+ XGL_FLAGS flags);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdEndQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT slot);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdResetQueryPool(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ XGL_UINT startQuery,
+ XGL_UINT queryCount);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdWriteTimestamp(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_TIMESTAMP_TYPE timestampType,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdInitAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ const XGL_UINT32* pData);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdLoadAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY srcMem,
+ XGL_GPU_SIZE srcOffset);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdSaveAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_UINT startCounter,
+ XGL_UINT counterCount,
+ XGL_GPU_MEMORY destMem,
+ XGL_GPU_SIZE destOffset);
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl_structs.h
new file mode 100644
index 0000000..3fba90e
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgl_structs.h
@@ -0,0 +1,2008 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "xgl/inc/xgl.h"
+#include "glv_trace_packet_utils.h"
+
+static const char* string_XGL_RESULT(XGL_RESULT result)
+{
+ switch ((XGL_RESULT)result)
+ {
+ // Return codes for successful operation execution
+ case XGL_SUCCESS:
+ return "XGL_SUCCESS";
+ case XGL_UNSUPPORTED:
+ return "XGL_UNSUPPORTED";
+ case XGL_NOT_READY:
+ return "XGL_NOT_READY";
+ case XGL_TIMEOUT:
+ return "XGL_TIMEOUT";
+ case XGL_EVENT_SET:
+ return "XGL_EVENT_SET";
+ case XGL_EVENT_RESET:
+ return "XGL_EVENT_RESET";
+ // Error codes
+ case XGL_ERROR_UNKNOWN:
+ return "XGL_ERROR_UNKNOWN";
+ case XGL_ERROR_UNAVAILABLE:
+ return "XGL_ERROR_UNAVAILABLE";
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ return "XGL_ERROR_INITIALIZATION_FAILED";
+ case XGL_ERROR_OUT_OF_MEMORY:
+ return "XGL_ERROR_OUT_OF_MEMORY";
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+ case XGL_ERROR_DEVICE_LOST:
+ return "XGL_ERROR_DEVICE_LOST";
+ case XGL_ERROR_INVALID_POINTER:
+ return "XGL_ERROR_INVALID_POINTER";
+ case XGL_ERROR_INVALID_VALUE:
+ return "XGL_ERROR_INVALID_VALUE";
+ case XGL_ERROR_INVALID_HANDLE:
+ return "XGL_ERROR_INVALID_HANDLE";
+ case XGL_ERROR_INVALID_ORDINAL:
+ return "XGL_ERROR_INVALID_ORDINAL";
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ return "XGL_ERROR_INVALID_MEMORY_SIZE";
+ case XGL_ERROR_INVALID_EXTENSION:
+ return "XGL_ERROR_INVALID_EXTENSION";
+ case XGL_ERROR_INVALID_FLAGS:
+ return "XGL_ERROR_INVALID_FLAGS";
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ return "XGL_ERROR_INVALID_ALIGNMENT";
+ case XGL_ERROR_INVALID_FORMAT:
+ return "XGL_ERROR_INVALID_FORMAT";
+ case XGL_ERROR_INVALID_IMAGE:
+ return "XGL_ERROR_INVALID_IMAGE";
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ return "XGL_ERROR_INVALID_QUEUE_TYPE";
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ return "XGL_ERROR_INVALID_OBJECT_TYPE";
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+ case XGL_ERROR_BAD_SHADER_CODE:
+ return "XGL_ERROR_BAD_SHADER_CODE";
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ return "XGL_ERROR_BAD_PIPELINE_DATA";
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+ case XGL_ERROR_NOT_MAPPABLE:
+ return "XGL_ERROR_NOT_MAPPABLE";
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ return "XGL_ERROR_MEMORY_MAP_FAILED";
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ return "XGL_ERROR_MEMORY_NOT_BOUND";
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+ case XGL_ERROR_NOT_SHAREABLE:
+ return "XGL_ERROR_NOT_SHAREABLE";
+ }
+ return "Unhandled XGL_RESULT";
+}
+
+//=============================================================================
+static uint64_t calc_size_XGL_APPLICATION_INFO(const XGL_APPLICATION_INFO* pStruct)
+{
+ return ((pStruct == NULL) ? 0 : sizeof(XGL_APPLICATION_INFO)) + strlen((const char *)pStruct->pAppName) + 1 + strlen((const char *)pStruct->pEngineName) + 1;
+}
+
+static void add_XGL_APPLICATION_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_APPLICATION_INFO** ppStruct, const XGL_APPLICATION_INFO *pInStruct)
+{
+ glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen((const char *)pInStruct->pAppName) + 1, (const char *)pInStruct->pAppName);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen((const char *)pInStruct->pEngineName) + 1, (const char *)pInStruct->pEngineName);
+ glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));
+ glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));
+ glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);
+};
+
+//=============================================================================
+
+static uint64_t calc_size_XGL_DEVICE_CREATE_INFO(const XGL_DEVICE_CREATE_INFO* pStruct)
+{
+ uint64_t total_size_ppEnabledExtensionNames = pStruct->extensionCount * sizeof(XGL_CHAR *);
+ uint32_t i;
+ for (i = 0; i < pStruct->extensionCount; i++)
+ {
+ total_size_ppEnabledExtensionNames += strlen((const char *)pStruct->ppEnabledExtensionNames[i]) + 1;
+ }
+
+ return sizeof(XGL_DEVICE_CREATE_INFO) + (pStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO)) + total_size_ppEnabledExtensionNames;
+}
+
+static void add_XGL_DEVICE_CREATE_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_DEVICE_CREATE_INFO** ppStruct, const XGL_DEVICE_CREATE_INFO *pInStruct)
+{
+ uint32_t i;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);
+
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO), pInStruct->pRequestedQueues);
+ glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);
+
+ if (pInStruct->extensionCount > 0)
+ {
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(XGL_CHAR *), pInStruct->ppEnabledExtensionNames);
+ for (i = 0; i < pInStruct->extensionCount; i++)
+ {
+
+ glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen((const char *)pInStruct->ppEnabledExtensionNames[i]) + 1, (const char *)pInStruct->ppEnabledExtensionNames[i]);
+ glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));
+ }
+ glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);
+ }
+ glv_finalize_buffer_address(pHeader, (void**)ppStruct);
+}
+
+static XGL_DEVICE_CREATE_INFO* intepret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)
+{
+ XGL_DEVICE_CREATE_INFO* pXGL_DEVICE_CREATE_INFO = (XGL_DEVICE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);
+
+ if (pXGL_DEVICE_CREATE_INFO != NULL)
+ {
+ pXGL_DEVICE_CREATE_INFO->pRequestedQueues = (const XGL_DEVICE_QUEUE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pRequestedQueues);
+
+ if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)
+ {
+ const XGL_CHAR** pNames;
+ uint32_t i;
+ pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames = (const XGL_CHAR *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames);
+ pNames = (const XGL_CHAR**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;
+ for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)
+ {
+ pNames[i] = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));
+ }
+ }
+ }
+
+ return pXGL_DEVICE_CREATE_INFO;
+}
+
+//=============================================================================
+// entrypoints
+
+typedef struct struct_xglInitAndEnumerateGpus {
+ glv_trace_packet_header* header;
+ const XGL_APPLICATION_INFO* pAppInfo;
+ const XGL_ALLOC_CALLBACKS* pAllocCb;
+ XGL_UINT maxGpus;
+ XGL_UINT* pGpuCount;
+ XGL_PHYSICAL_GPU* pGpus;
+ XGL_RESULT result;
+} struct_xglInitAndEnumerateGpus;
+
+static struct_xglInitAndEnumerateGpus* interpret_body_as_xglInitAndEnumerateGpus(glv_trace_packet_header* pHeader)
+{
+ struct_xglInitAndEnumerateGpus* pPacket = (struct_xglInitAndEnumerateGpus*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pAppInfo = (const XGL_APPLICATION_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo);
+ if (pPacket->pAppInfo != NULL)
+ {
+ XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;
+ pInfo->pAppName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);
+ pInfo->pEngineName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);
+ }
+ pPacket->pAllocCb = (const XGL_ALLOC_CALLBACKS*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocCb);
+ pPacket->pGpuCount = (XGL_UINT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pGpuCount);
+ pPacket->pGpus = (XGL_PHYSICAL_GPU*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pGpus);
+ return pPacket;
+}
+
+typedef struct struct_xglGetGpuInfo {
+ glv_trace_packet_header* header;
+ XGL_PHYSICAL_GPU gpu;
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglGetGpuInfo;
+
+static struct_xglGetGpuInfo* interpret_body_as_xglGetGpuInfo(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetGpuInfo* pPacket = (struct_xglGetGpuInfo*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+// Device functions
+
+typedef struct struct_xglCreateDevice {
+ glv_trace_packet_header* header;
+ XGL_PHYSICAL_GPU gpu;
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo;
+ XGL_DEVICE* pDevice;
+ XGL_RESULT result;
+} struct_xglCreateDevice;
+
+static struct_xglCreateDevice* interpret_body_as_xglCreateDevice(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateDevice* pPacket = (struct_xglCreateDevice*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = intepret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pDevice = (XGL_DEVICE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDevice);
+ return pPacket;
+}
+
+typedef struct struct_xglDestroyDevice {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_RESULT result;
+} struct_xglDestroyDevice;
+
+static struct_xglDestroyDevice* interpret_body_as_xglDestroyDevice(glv_trace_packet_header* pHeader)
+{
+ struct_xglDestroyDevice* pPacket = (struct_xglDestroyDevice*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// Extension discovery functions
+
+typedef struct struct_xglGetExtensionSupport {
+ glv_trace_packet_header* header;
+ XGL_PHYSICAL_GPU gpu;
+ const XGL_CHAR* pExtName;
+ XGL_RESULT result;
+} struct_xglGetExtensionSupport;
+
+static struct_xglGetExtensionSupport* interpret_body_as_xglGetExtensionSupport(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetExtensionSupport* pPacket = (struct_xglGetExtensionSupport*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pExtName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pExtName);
+ return pPacket;
+}
+
+// Queue functions
+
+typedef struct struct_xglGetDeviceQueue {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_QUEUE_TYPE queueType;
+ XGL_UINT queueIndex;
+ XGL_QUEUE* pQueue;
+ XGL_RESULT result;
+} struct_xglGetDeviceQueue;
+
+static struct_xglGetDeviceQueue* interpret_body_as_xglGetDeviceQueue(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetDeviceQueue* pPacket = (struct_xglGetDeviceQueue*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pQueue = (XGL_QUEUE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pQueue);
+ return pPacket;
+}
+
+typedef struct struct_xglQueueSubmit {
+ glv_trace_packet_header* header;
+ XGL_QUEUE queue;
+ XGL_UINT cmdBufferCount;
+ const XGL_CMD_BUFFER* pCmdBuffers;
+ XGL_UINT memRefCount;
+ const XGL_MEMORY_REF* pMemRefs;
+ XGL_FENCE fence;
+ XGL_RESULT result;
+} struct_xglQueueSubmit;
+
+static struct_xglQueueSubmit* interpret_body_as_xglQueueSubmit(glv_trace_packet_header* pHeader)
+{
+ struct_xglQueueSubmit* pPacket = (struct_xglQueueSubmit*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCmdBuffers = (const XGL_CMD_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCmdBuffers);
+ pPacket->pMemRefs = (const XGL_MEMORY_REF*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMemRefs);
+ return pPacket;
+}
+
+typedef struct struct_xglQueueSetGlobalMemReferences {
+ glv_trace_packet_header* header;
+ XGL_QUEUE queue;
+ XGL_UINT memRefCount;
+ const XGL_MEMORY_REF* pMemRefs;
+ XGL_RESULT result;
+} struct_xglQueueSetGlobalMemReferences;
+
+static struct_xglQueueSetGlobalMemReferences* interpret_body_as_xglQueueSetGlobalMemReferences(glv_trace_packet_header* pHeader)
+{
+ struct_xglQueueSetGlobalMemReferences* pPacket = (struct_xglQueueSetGlobalMemReferences*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pMemRefs = (const XGL_MEMORY_REF*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMemRefs);
+ return pPacket;
+}
+
+typedef struct struct_xglQueueWaitIdle {
+ glv_trace_packet_header* header;
+ XGL_QUEUE queue;
+ XGL_RESULT result;
+} struct_xglQueueWaitIdle;
+
+static struct_xglQueueWaitIdle* interpret_body_as_xglQueueWaitIdle(glv_trace_packet_header* pHeader)
+{
+ struct_xglQueueWaitIdle* pPacket = (struct_xglQueueWaitIdle*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglDeviceWaitIdle {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_RESULT result;
+} struct_xglDeviceWaitIdle;
+
+static struct_xglDeviceWaitIdle* interpret_body_as_xglDeviceWaitIdle(glv_trace_packet_header* pHeader)
+{
+ struct_xglDeviceWaitIdle* pPacket = (struct_xglDeviceWaitIdle*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// Memory functions
+
+typedef struct struct_xglGetMemoryHeapCount {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_UINT* pCount;
+ XGL_RESULT result;
+} struct_xglGetMemoryHeapCount;
+
+static struct_xglGetMemoryHeapCount* interpret_body_as_xglGetMemoryHeapCount(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetMemoryHeapCount* pPacket = (struct_xglGetMemoryHeapCount*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCount = (XGL_UINT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCount);
+ return pPacket;
+}
+
+typedef struct struct_xglGetMemoryHeapInfo {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_UINT heapId;
+ XGL_MEMORY_HEAP_INFO_TYPE infoType;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglGetMemoryHeapInfo;
+
+static struct_xglGetMemoryHeapInfo* interpret_body_as_xglGetMemoryHeapInfo(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetMemoryHeapInfo* pPacket = (struct_xglGetMemoryHeapInfo*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglAllocMemory {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo;
+ XGL_GPU_MEMORY* pMem;
+ XGL_RESULT result;
+} struct_xglAllocMemory;
+
+static struct_xglAllocMemory* interpret_body_as_xglAllocMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pAllocInfo = (const XGL_MEMORY_ALLOC_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAllocInfo);
+ pPacket->pMem = (XGL_GPU_MEMORY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMem);
+ return pPacket;
+}
+
+typedef struct struct_xglFreeMemory {
+ glv_trace_packet_header* header;
+ XGL_GPU_MEMORY mem;
+ XGL_RESULT result;
+} struct_xglFreeMemory;
+
+static struct_xglFreeMemory* interpret_body_as_xglFreeMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglSetMemoryPriority {
+ glv_trace_packet_header* header;
+ XGL_GPU_MEMORY mem;
+ XGL_MEMORY_PRIORITY priority;
+ XGL_RESULT result;
+} struct_xglSetMemoryPriority;
+
+static struct_xglSetMemoryPriority* interpret_body_as_xglSetMemoryPriority(glv_trace_packet_header* pHeader)
+{
+ struct_xglSetMemoryPriority* pPacket = (struct_xglSetMemoryPriority*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglMapMemory {
+ glv_trace_packet_header* header;
+ XGL_GPU_MEMORY mem;
+ XGL_FLAGS flags; // Reserved
+ XGL_VOID** ppData;
+ XGL_RESULT result;
+} struct_xglMapMemory;
+
+static struct_xglMapMemory* interpret_body_as_xglMapMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglMapMemory* pPacket = (struct_xglMapMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->ppData = (XGL_VOID**)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->ppData);
+ return pPacket;
+}
+
+typedef struct struct_xglUnmapMemory {
+ glv_trace_packet_header* header;
+ XGL_GPU_MEMORY mem;
+ XGL_VOID *pData; //Data CPU potentially wrote into
+ XGL_RESULT result;
+} struct_xglUnmapMemory;
+
+static struct_xglUnmapMemory* interpret_body_as_xglUnmapMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pData = (XGL_VOID *)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglPinSystemMemory {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_VOID* pSysMem;
+ XGL_SIZE memSize;
+ XGL_GPU_MEMORY* pMem;
+ XGL_RESULT result;
+} struct_xglPinSystemMemory;
+
+static struct_xglPinSystemMemory* interpret_body_as_xglPinSystemMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pSysMem = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSysMem);
+ pPacket->pMem = (XGL_GPU_MEMORY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMem);
+ return pPacket;
+}
+
+typedef struct struct_xglRemapVirtualMemoryPages {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_UINT rangeCount;
+ const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges;
+ XGL_UINT preWaitSemaphoreCount;
+ const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores;
+ XGL_UINT postSignalSemaphoreCount;
+ const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores;
+ XGL_RESULT result;
+} struct_xglRemapVirtualMemoryPages;
+
+static struct_xglRemapVirtualMemoryPages* interpret_body_as_xglRemapVirtualMemoryPages(glv_trace_packet_header* pHeader)
+{
+ struct_xglRemapVirtualMemoryPages* pPacket = (struct_xglRemapVirtualMemoryPages*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRanges = (const XGL_VIRTUAL_MEMORY_REMAP_RANGE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRanges);
+ pPacket->pPreWaitSemaphores = (const XGL_QUEUE_SEMAPHORE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pPreWaitSemaphores);
+ pPacket->pPostSignalSemaphores = (const XGL_QUEUE_SEMAPHORE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pPostSignalSemaphores);
+ return pPacket;
+}
+
+// Multi-device functions
+
+typedef struct struct_xglGetMultiGpuCompatibility {
+ glv_trace_packet_header* header;
+ XGL_PHYSICAL_GPU gpu0;
+ XGL_PHYSICAL_GPU gpu1;
+ XGL_GPU_COMPATIBILITY_INFO* pInfo;
+ XGL_RESULT result;
+} struct_xglGetMultiGpuCompatibility;
+
+static struct_xglGetMultiGpuCompatibility* interpret_body_as_xglGetMultiGpuCompatibility(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetMultiGpuCompatibility* pPacket = (struct_xglGetMultiGpuCompatibility*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pInfo = (XGL_GPU_COMPATIBILITY_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pInfo);
+ return pPacket;
+}
+
+typedef struct struct_xglOpenSharedMemory {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo;
+ XGL_GPU_MEMORY* pMem;
+ XGL_RESULT result;
+} struct_xglOpenSharedMemory;
+
+static struct_xglOpenSharedMemory* interpret_body_as_xglOpenSharedMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglOpenSharedMemory* pPacket = (struct_xglOpenSharedMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pOpenInfo = (const XGL_MEMORY_OPEN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pOpenInfo);
+ pPacket->pMem = (XGL_GPU_MEMORY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMem);
+ return pPacket;
+}
+
+typedef struct struct_xglOpenSharedQueueSemaphore {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo;
+ XGL_QUEUE_SEMAPHORE* pSemaphore;
+ XGL_RESULT result;
+} struct_xglOpenSharedQueueSemaphore;
+
+static struct_xglOpenSharedQueueSemaphore* interpret_body_as_xglOpenSharedQueueSemaphore(glv_trace_packet_header* pHeader)
+{
+ struct_xglOpenSharedQueueSemaphore* pPacket = (struct_xglOpenSharedQueueSemaphore*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pOpenInfo = (const XGL_QUEUE_SEMAPHORE_OPEN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pOpenInfo);
+ pPacket->pSemaphore = (XGL_QUEUE_SEMAPHORE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSemaphore);
+ return pPacket;
+}
+
+typedef struct struct_xglOpenPeerMemory {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo;
+ XGL_GPU_MEMORY* pMem;
+ XGL_RESULT result;
+} struct_xglOpenPeerMemory;
+
+static struct_xglOpenPeerMemory* interpret_body_as_xglOpenPeerMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglOpenPeerMemory* pPacket = (struct_xglOpenPeerMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pOpenInfo = (const XGL_PEER_MEMORY_OPEN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pOpenInfo);
+ return pPacket;
+}
+
+typedef struct struct_xglOpenPeerImage {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo;
+ XGL_IMAGE* pImage;
+ XGL_GPU_MEMORY* pMem;
+ XGL_RESULT result;
+} struct_xglOpenPeerImage;
+
+static struct_xglOpenPeerImage* interpret_body_as_xglOpenPeerImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglOpenPeerImage* pPacket = (struct_xglOpenPeerImage*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pOpenInfo = (const XGL_PEER_IMAGE_OPEN_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pOpenInfo);
+ return pPacket;
+}
+
+// Generic API object functions
+
+typedef struct struct_xglDestroyObject {
+ glv_trace_packet_header* header;
+ XGL_OBJECT object;
+ XGL_RESULT result;
+} struct_xglDestroyObject;
+
+static struct_xglDestroyObject* interpret_body_as_xglDestroyObject(glv_trace_packet_header* pHeader)
+{
+ struct_xglDestroyObject* pPacket = (struct_xglDestroyObject*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglGetObjectInfo {
+ glv_trace_packet_header* header;
+ XGL_BASE_OBJECT object;
+ XGL_OBJECT_INFO_TYPE infoType;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglGetObjectInfo;
+
+static struct_xglGetObjectInfo* interpret_body_as_xglGetObjectInfo(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetObjectInfo* pPacket = (struct_xglGetObjectInfo*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglBindObjectMemory {
+ glv_trace_packet_header* header;
+ XGL_OBJECT object;
+ XGL_GPU_MEMORY mem;
+ XGL_GPU_SIZE offset;
+ XGL_RESULT result;
+} struct_xglBindObjectMemory;
+
+static struct_xglBindObjectMemory* interpret_body_as_xglBindObjectMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglBindObjectMemory* pPacket = (struct_xglBindObjectMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// Fence functions
+
+typedef struct struct_xglCreateFence {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_FENCE_CREATE_INFO* pCreateInfo;
+ XGL_FENCE* pFence;
+ XGL_RESULT result;
+} struct_xglCreateFence;
+
+static struct_xglCreateFence* interpret_body_as_xglCreateFence(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateFence* pPacket = (struct_xglCreateFence*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (XGL_FENCE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pFence = (XGL_FENCE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pFence);
+ return pPacket;
+}
+
+typedef struct struct_xglGetFenceStatus {
+ glv_trace_packet_header* header;
+ XGL_FENCE fence;
+ XGL_RESULT result;
+} struct_xglGetFenceStatus;
+
+static struct_xglGetFenceStatus* interpret_body_as_xglGetFenceStatus(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetFenceStatus* pPacket = (struct_xglGetFenceStatus*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglWaitForFences {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_UINT fenceCount;
+ const XGL_FENCE* pFences;
+ XGL_BOOL waitAll;
+ XGL_UINT64 timeout;
+ XGL_RESULT result;
+} struct_xglWaitForFences;
+
+static struct_xglWaitForFences* interpret_body_as_xglWaitForFences(glv_trace_packet_header* pHeader)
+{
+ struct_xglWaitForFences* pPacket = (struct_xglWaitForFences*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pFences = (const XGL_FENCE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pFences);
+ return pPacket;
+}
+
+// Queue semaphore functions
+
+typedef struct struct_xglCreateQueueSemaphore {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo;
+ XGL_QUEUE_SEMAPHORE* pSemaphore;
+ XGL_RESULT result;
+} struct_xglCreateQueueSemaphore;
+
+static struct_xglCreateQueueSemaphore* interpret_body_as_xglCreateQueueSemaphore(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateQueueSemaphore* pPacket = (struct_xglCreateQueueSemaphore*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_QUEUE_SEMAPHORE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pSemaphore = (XGL_QUEUE_SEMAPHORE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSemaphore);
+ return pPacket;
+}
+
+typedef struct struct_xglSignalQueueSemaphore {
+ glv_trace_packet_header* header;
+ XGL_QUEUE queue;
+ XGL_QUEUE_SEMAPHORE semaphore;
+ XGL_RESULT result;
+} struct_xglSignalQueueSemaphore;
+
+static struct_xglSignalQueueSemaphore* interpret_body_as_xglSignalQueueSemaphore(glv_trace_packet_header* pHeader)
+{
+ struct_xglSignalQueueSemaphore* pPacket = (struct_xglSignalQueueSemaphore*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglWaitQueueSemaphore {
+ glv_trace_packet_header* header;
+ XGL_QUEUE queue;
+ XGL_QUEUE_SEMAPHORE semaphore;
+ XGL_RESULT result;
+} struct_xglWaitQueueSemaphore;
+
+static struct_xglWaitQueueSemaphore* interpret_body_as_xglWaitQueueSemaphore(glv_trace_packet_header* pHeader)
+{
+ struct_xglWaitQueueSemaphore* pPacket = (struct_xglWaitQueueSemaphore*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// Event functions
+
+typedef struct struct_xglCreateEvent {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_EVENT_CREATE_INFO* pCreateInfo;
+ XGL_EVENT* pEvent;
+ XGL_RESULT result;
+} struct_xglCreateEvent;
+
+static struct_xglCreateEvent* interpret_body_as_xglCreateEvent(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateEvent* pPacket = (struct_xglCreateEvent*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_EVENT_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pEvent = (XGL_EVENT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pEvent);
+ return pPacket;
+}
+
+typedef struct struct_xglGetEventStatus {
+ glv_trace_packet_header* header;
+ XGL_EVENT event;
+ XGL_RESULT result;
+} struct_xglGetEventStatus;
+
+static struct_xglGetEventStatus* interpret_body_as_xglGetEventStatus(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetEventStatus* pPacket = (struct_xglGetEventStatus*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglSetEvent {
+ glv_trace_packet_header* header;
+ XGL_EVENT event;
+ XGL_RESULT result;
+} struct_xglSetEvent;
+
+static struct_xglSetEvent* interpret_body_as_xglSetEvent(glv_trace_packet_header* pHeader)
+{
+ struct_xglSetEvent* pPacket = (struct_xglSetEvent*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglResetEvent {
+ glv_trace_packet_header* header;
+ XGL_EVENT event;
+ XGL_RESULT result;
+} struct_xglResetEvent;
+
+static struct_xglResetEvent* interpret_body_as_xglResetEvent(glv_trace_packet_header* pHeader)
+{
+ struct_xglResetEvent* pPacket = (struct_xglResetEvent*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// Query functions
+
+typedef struct struct_xglCreateQueryPool {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo;
+ XGL_QUERY_POOL* pQueryPool;
+ XGL_RESULT result;
+} struct_xglCreateQueryPool;
+
+static struct_xglCreateQueryPool* interpret_body_as_xglCreateQueryPool(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateQueryPool* pPacket = (struct_xglCreateQueryPool*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_QUERY_POOL_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pQueryPool = (XGL_QUERY_POOL*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pQueryPool);
+ return pPacket;
+}
+
+typedef struct struct_xglGetQueryPoolResults {
+ glv_trace_packet_header* header;
+ XGL_QUERY_POOL queryPool;
+ XGL_UINT startQuery;
+ XGL_UINT queryCount;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglGetQueryPoolResults;
+
+static struct_xglGetQueryPoolResults* interpret_body_as_xglGetQueryPoolResults(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetQueryPoolResults* pPacket = (struct_xglGetQueryPoolResults*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+// Format capabilities
+
+typedef struct struct_xglGetFormatInfo {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_FORMAT format;
+ XGL_FORMAT_INFO_TYPE infoType;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglGetFormatInfo;
+
+static struct_xglGetFormatInfo* interpret_body_as_xglGetFormatInfo(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetFormatInfo* pPacket = (struct_xglGetFormatInfo*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+// Image functions
+
+typedef struct struct_xglCreateImage {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo;
+ XGL_IMAGE* pImage;
+ XGL_RESULT result;
+} struct_xglCreateImage;
+
+static struct_xglCreateImage* interpret_body_as_xglCreateImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateImage* pPacket = (struct_xglCreateImage*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_IMAGE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pImage = (XGL_IMAGE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pImage);
+ return pPacket;
+}
+
+typedef struct struct_xglGetImageSubresourceInfo {
+ glv_trace_packet_header* header;
+ XGL_IMAGE image;
+ const XGL_IMAGE_SUBRESOURCE* pSubresource;
+ XGL_SUBRESOURCE_INFO_TYPE infoType;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglGetImageSubresourceInfo;
+
+static struct_xglGetImageSubresourceInfo* interpret_body_as_xglGetImageSubresourceInfo(glv_trace_packet_header* pHeader)
+{
+ struct_xglGetImageSubresourceInfo* pPacket = (struct_xglGetImageSubresourceInfo*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pSubresource = (const XGL_IMAGE_SUBRESOURCE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSubresource);
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+// Image view functions
+
+typedef struct struct_xglCreateImageView {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo;
+ XGL_IMAGE_VIEW* pView;
+ XGL_RESULT result;
+} struct_xglCreateImageView;
+
+static struct_xglCreateImageView* interpret_body_as_xglCreateImageView(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateImageView* pPacket = (struct_xglCreateImageView*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_IMAGE_VIEW_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pView = (XGL_IMAGE_VIEW*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pView);
+ return pPacket;
+}
+
+typedef struct struct_xglCreateColorAttachmentView {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo;
+ XGL_COLOR_ATTACHMENT_VIEW* pView;
+ XGL_RESULT result;
+} struct_xglCreateColorAttachmentView;
+
+static struct_xglCreateColorAttachmentView* interpret_body_as_xglCreateColorAttachmentView(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateColorAttachmentView* pPacket = (struct_xglCreateColorAttachmentView*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pView = (XGL_COLOR_ATTACHMENT_VIEW*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pView);
+ return pPacket;
+}
+
+typedef struct struct_xglCreateDepthStencilView {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo;
+ XGL_DEPTH_STENCIL_VIEW* pView;
+ XGL_RESULT result;
+} struct_xglCreateDepthStencilView;
+
+static struct_xglCreateDepthStencilView* interpret_body_as_xglCreateDepthStencilView(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateDepthStencilView* pPacket = (struct_xglCreateDepthStencilView*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pView = (XGL_DEPTH_STENCIL_VIEW*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pView);
+ return pPacket;
+}
+
+// Shader functions
+
+typedef struct struct_xglCreateShader {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_SHADER_CREATE_INFO* pCreateInfo;
+ XGL_SHADER* pShader;
+ XGL_RESULT result;
+} struct_xglCreateShader;
+
+static struct_xglCreateShader* interpret_body_as_xglCreateShader(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateShader* pPacket = (struct_xglCreateShader*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_SHADER_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pShader = (XGL_SHADER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pShader);
+ if (pPacket->pCreateInfo != NULL)
+ {
+ XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;
+ pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);
+ }
+ return pPacket;
+}
+
+// Pipeline functions
+
+typedef struct struct_xglCreateGraphicsPipeline {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo;
+ XGL_PIPELINE* pPipeline;
+ XGL_RESULT result;
+} struct_xglCreateGraphicsPipeline;
+
+static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)
+{
+ XGL_UINT i, j;
+ if (pShader != NULL)
+ {
+ // descriptor sets
+ // TODO: need to ensure XGL_MAX_DESCRIPTOR_SETS is equal in replay as it was at trace time - meta data
+ for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)
+ {
+ pShader->descriptorSetMapping[i].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->descriptorSetMapping[i].pDescriptorInfo);
+ for (j = 0; j < pShader->descriptorSetMapping[i].descriptorCount; j++)
+ {
+ if (pShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)
+ {
+ XGL_DESCRIPTOR_SLOT_INFO* pInfo = (XGL_DESCRIPTOR_SLOT_INFO*)pShader->descriptorSetMapping[i].pDescriptorInfo;
+ pInfo[j].pNextLevelSet = (const XGL_DESCRIPTOR_SET_MAPPING*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet);
+ }
+ }
+ }
+
+ // constant buffers
+ if (pShader->linkConstBufferCount > 0)
+ {
+ XGL_UINT i;
+ pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);
+ for (i = 0; i < pShader->linkConstBufferCount; i++)
+ {
+ XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;
+ pBuffer[i].pBufferData = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);
+ }
+ }
+ }
+}
+
+static struct_xglCreateGraphicsPipeline* interpret_body_as_xglCreateGraphicsPipeline(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateGraphicsPipeline* pPacket = (struct_xglCreateGraphicsPipeline*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pPipeline = (XGL_PIPELINE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pPipeline);
+ pPacket->pCreateInfo = (const XGL_GRAPHICS_PIPELINE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+
+ if (pPacket->pCreateInfo != NULL)
+ {
+ assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
+
+ // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one
+ XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pPacket->pCreateInfo->pNext;
+ *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);
+
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;
+ while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))
+ {
+ switch(pNext->sType)
+ {
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ {
+ XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pNext->pNext;
+ *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);
+ break;
+ }
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ {
+ XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pNext->pNext;
+ *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);
+
+ interpret_pipeline_shader(pHeader, &pNext->shader);
+
+ break;
+ }
+ default:
+ assert(!"Encountered an unexpected type in pipeline state list");
+ }
+
+ pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;
+ }
+ }
+ return pPacket;
+}
+
+typedef struct struct_xglCreateComputePipeline {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo;
+ XGL_PIPELINE* pPipeline;
+ XGL_RESULT result;
+} struct_xglCreateComputePipeline;
+
+static struct_xglCreateComputePipeline* interpret_body_as_xglCreateComputePipeline(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateComputePipeline* pPacket = (struct_xglCreateComputePipeline*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_COMPUTE_PIPELINE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ if (pPacket->pCreateInfo != NULL)
+ {
+ interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));
+ }
+ pPacket->pPipeline = (XGL_PIPELINE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pPipeline);
+ return pPacket;
+}
+
+typedef struct struct_xglStorePipeline {
+ glv_trace_packet_header* header;
+ XGL_PIPELINE pipeline;
+ XGL_SIZE* pDataSize;
+ XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglStorePipeline;
+
+static struct_xglStorePipeline* interpret_body_as_xglStorePipeline(glv_trace_packet_header* pHeader)
+{
+ struct_xglStorePipeline* pPacket = (struct_xglStorePipeline*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pDataSize = (XGL_SIZE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDataSize);
+ pPacket->pData = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglLoadPipeline {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_SIZE dataSize;
+ const XGL_VOID* pData;
+ XGL_PIPELINE* pPipeline;
+ XGL_RESULT result;
+} struct_xglLoadPipeline;
+
+static struct_xglLoadPipeline* interpret_body_as_xglLoadPipeline(glv_trace_packet_header* pHeader)
+{
+ struct_xglLoadPipeline* pPacket = (struct_xglLoadPipeline*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pData = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ pPacket->pPipeline = (XGL_PIPELINE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pPipeline);
+ return pPacket;
+}
+typedef struct struct_xglCreatePipelineDelta {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ XGL_PIPELINE p1;
+ XGL_PIPELINE p2;
+ XGL_PIPELINE_DELTA* delta;
+ XGL_RESULT result;
+} struct_xglCreatePipelineDelta;
+
+static struct_xglCreatePipelineDelta* interpret_body_as_xglCreatePipelineDelta(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreatePipelineDelta* pPacket = (struct_xglCreatePipelineDelta*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->delta = (XGL_PIPELINE_DELTA*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->delta);
+ return pPacket;
+}
+
+// Sampler functions
+
+typedef struct struct_xglCreateSampler {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo;
+ XGL_SAMPLER* pSampler;
+ XGL_RESULT result;
+} struct_xglCreateSampler;
+
+static struct_xglCreateSampler* interpret_body_as_xglCreateSampler(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateSampler* pPacket = (struct_xglCreateSampler*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_SAMPLER_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pSampler = (XGL_SAMPLER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSampler);
+ return pPacket;
+}
+
+// Descriptor set functions
+
+typedef struct struct_xglCreateDescriptorSet {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo;
+ XGL_DESCRIPTOR_SET* pDescriptorSet;
+ XGL_RESULT result;
+} struct_xglCreateDescriptorSet;
+
+static struct_xglCreateDescriptorSet* interpret_body_as_xglCreateDescriptorSet(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateDescriptorSet* pPacket = (struct_xglCreateDescriptorSet*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_DESCRIPTOR_SET_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pDescriptorSet = (XGL_DESCRIPTOR_SET*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDescriptorSet);
+ return pPacket;
+}
+
+typedef struct struct_xglBeginDescriptorSetUpdate {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+} struct_xglBeginDescriptorSetUpdate;
+
+static struct_xglBeginDescriptorSetUpdate* interpret_body_as_xglBeginDescriptorSetUpdate(glv_trace_packet_header* pHeader)
+{
+ struct_xglBeginDescriptorSetUpdate* pPacket = (struct_xglBeginDescriptorSetUpdate*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglEndDescriptorSetUpdate {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+} struct_xglEndDescriptorSetUpdate;
+
+static struct_xglEndDescriptorSetUpdate* interpret_body_as_xglEndDescriptorSetUpdate(glv_trace_packet_header* pHeader)
+{
+ struct_xglEndDescriptorSetUpdate* pPacket = (struct_xglEndDescriptorSetUpdate*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglAttachSamplerDescriptors {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT startSlot;
+ XGL_UINT slotCount;
+ const XGL_SAMPLER* pSamplers;
+} struct_xglAttachSamplerDescriptors;
+
+static struct_xglAttachSamplerDescriptors* interpret_body_as_xglAttachSamplerDescriptors(glv_trace_packet_header* pHeader)
+{
+ struct_xglAttachSamplerDescriptors* pPacket = (struct_xglAttachSamplerDescriptors*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pSamplers = (const XGL_SAMPLER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSamplers);
+ return pPacket;
+}
+
+typedef struct struct_xglAttachImageViewDescriptors {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT startSlot;
+ XGL_UINT slotCount;
+ const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews;
+} struct_xglAttachImageViewDescriptors;
+
+static struct_xglAttachImageViewDescriptors* interpret_body_as_xglAttachImageViewDescriptors(glv_trace_packet_header* pHeader)
+{
+ struct_xglAttachImageViewDescriptors* pPacket = (struct_xglAttachImageViewDescriptors*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pImageViews = (const XGL_IMAGE_VIEW_ATTACH_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pImageViews);
+ return pPacket;
+}
+
+typedef struct struct_xglAttachMemoryViewDescriptors {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT startSlot;
+ XGL_UINT slotCount;
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews;
+} struct_xglAttachMemoryViewDescriptors;
+
+static struct_xglAttachMemoryViewDescriptors* interpret_body_as_xglAttachMemoryViewDescriptors(glv_trace_packet_header* pHeader)
+{
+ struct_xglAttachMemoryViewDescriptors* pPacket = (struct_xglAttachMemoryViewDescriptors*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pMemViews = (const XGL_MEMORY_VIEW_ATTACH_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMemViews);
+ return pPacket;
+}
+
+typedef struct struct_xglAttachNestedDescriptors {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT startSlot;
+ XGL_UINT slotCount;
+ const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets;
+} struct_xglAttachNestedDescriptors;
+
+static struct_xglAttachNestedDescriptors* interpret_body_as_xglAttachNestedDescriptors(glv_trace_packet_header* pHeader)
+{
+ struct_xglAttachNestedDescriptors* pPacket = (struct_xglAttachNestedDescriptors*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pNestedDescriptorSets = (const XGL_DESCRIPTOR_SET_ATTACH_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pNestedDescriptorSets);
+ return pPacket;
+}
+
+typedef struct struct_xglClearDescriptorSetSlots {
+ glv_trace_packet_header* header;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT startSlot;
+ XGL_UINT slotCount;
+} struct_xglClearDescriptorSetSlots;
+
+static struct_xglClearDescriptorSetSlots* interpret_body_as_xglClearDescriptorSetSlots(glv_trace_packet_header* pHeader)
+{
+ struct_xglClearDescriptorSetSlots* pPacket = (struct_xglClearDescriptorSetSlots*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// State object functions
+
+typedef struct struct_xglCreateViewportState {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo;
+ XGL_VIEWPORT_STATE_OBJECT* pState;
+ XGL_RESULT result;
+} struct_xglCreateViewportState;
+
+static struct_xglCreateViewportState* interpret_body_as_xglCreateViewportState(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateViewportState* pPacket = (struct_xglCreateViewportState*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_VIEWPORT_STATE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pState = (XGL_VIEWPORT_STATE_OBJECT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pState);
+ return pPacket;
+}
+
+typedef struct struct_xglCreateRasterState {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo;
+ XGL_RASTER_STATE_OBJECT* pState;
+ XGL_RESULT result;
+} struct_xglCreateRasterState;
+
+static struct_xglCreateRasterState* interpret_body_as_xglCreateRasterState(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateRasterState* pPacket = (struct_xglCreateRasterState*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_RASTER_STATE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pState = (XGL_RASTER_STATE_OBJECT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pState);
+ return pPacket;
+}
+
+typedef struct struct_xglCreateMsaaState {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo;
+ XGL_MSAA_STATE_OBJECT* pState;
+ XGL_RESULT result;
+} struct_xglCreateMsaaState;
+
+static struct_xglCreateMsaaState* interpret_body_as_xglCreateMsaaState(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateMsaaState* pPacket = (struct_xglCreateMsaaState*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_MSAA_STATE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pState = (XGL_MSAA_STATE_OBJECT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pState);
+ return pPacket;
+}
+
+typedef struct struct_xglCreateColorBlendState {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo;
+ XGL_COLOR_BLEND_STATE_OBJECT* pState;
+ XGL_RESULT result;
+} struct_xglCreateColorBlendState;
+
+static struct_xglCreateColorBlendState* interpret_body_as_xglCreateColorBlendState(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateColorBlendState* pPacket = (struct_xglCreateColorBlendState*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_COLOR_BLEND_STATE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pState = (XGL_COLOR_BLEND_STATE_OBJECT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pState);
+ return pPacket;
+}
+
+typedef struct struct_xglCreateDepthStencilState {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo;
+ XGL_DEPTH_STENCIL_STATE_OBJECT* pState;
+ XGL_RESULT result;
+} struct_xglCreateDepthStencilState;
+
+static struct_xglCreateDepthStencilState* interpret_body_as_xglCreateDepthStencilState(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateDepthStencilState* pPacket = (struct_xglCreateDepthStencilState*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_DEPTH_STENCIL_STATE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pState = (XGL_DEPTH_STENCIL_STATE_OBJECT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pState);
+ return pPacket;
+}
+
+// Command buffer functions
+
+typedef struct struct_xglCreateCommandBuffer {
+ glv_trace_packet_header* header;
+ XGL_DEVICE device;
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo;
+ XGL_CMD_BUFFER* pCmdBuffer;
+ XGL_RESULT result;
+} struct_xglCreateCommandBuffer;
+
+static struct_xglCreateCommandBuffer* interpret_body_as_xglCreateCommandBuffer(glv_trace_packet_header* pHeader)
+{
+ struct_xglCreateCommandBuffer* pPacket = (struct_xglCreateCommandBuffer*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pCreateInfo = (const XGL_CMD_BUFFER_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pCmdBuffer = (XGL_CMD_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCmdBuffer);
+ return pPacket;
+}
+
+typedef struct struct_xglBeginCommandBuffer {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_FLAGS flags; // XGL_CMD_BUFFER_BUILD_FLAG
+ XGL_RESULT result;
+} struct_xglBeginCommandBuffer;
+
+static struct_xglBeginCommandBuffer* interpret_body_as_xglBeginCommandBuffer(glv_trace_packet_header* pHeader)
+{
+ struct_xglBeginCommandBuffer* pPacket = (struct_xglBeginCommandBuffer*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglEndCommandBuffer {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_RESULT result;
+} struct_xglEndCommandBuffer;
+
+static struct_xglEndCommandBuffer* interpret_body_as_xglEndCommandBuffer(glv_trace_packet_header* pHeader)
+{
+ struct_xglEndCommandBuffer* pPacket = (struct_xglEndCommandBuffer*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglResetCommandBuffer {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_RESULT result;
+} struct_xglResetCommandBuffer;
+
+static struct_xglResetCommandBuffer* interpret_body_as_xglResetCommandBuffer(glv_trace_packet_header* pHeader)
+{
+ struct_xglResetCommandBuffer* pPacket = (struct_xglResetCommandBuffer*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+// Command buffer building functions
+
+typedef struct struct_xglCmdBindPipeline {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ XGL_PIPELINE pipeline;
+} struct_xglCmdBindPipeline;
+
+static struct_xglCmdBindPipeline* interpret_body_as_xglCmdBindPipeline(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindPipeline* pPacket = (struct_xglCmdBindPipeline*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBindPipelineDelta {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ XGL_PIPELINE_DELTA delta;
+} struct_xglCmdBindPipelineDelta;
+
+static struct_xglCmdBindPipelineDelta* interpret_body_as_xglCmdBindPipelineDelta(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindPipelineDelta* pPacket = (struct_xglCmdBindPipelineDelta*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBindStateObject {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_STATE_BIND_POINT stateBindPoint;
+ XGL_STATE_OBJECT state;
+} struct_xglCmdBindStateObject;
+
+static struct_xglCmdBindStateObject* interpret_body_as_xglCmdBindStateObject(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindStateObject* pPacket = (struct_xglCmdBindStateObject*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBindDescriptorSet {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ XGL_UINT index;
+ XGL_DESCRIPTOR_SET descriptorSet;
+ XGL_UINT slotOffset;
+} struct_xglCmdBindDescriptorSet;
+
+static struct_xglCmdBindDescriptorSet* interpret_body_as_xglCmdBindDescriptorSet(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindDescriptorSet* pPacket = (struct_xglCmdBindDescriptorSet*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBindDynamicMemoryView {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView;
+} struct_xglCmdBindDynamicMemoryView;
+
+static struct_xglCmdBindDynamicMemoryView* interpret_body_as_xglCmdBindDynamicMemoryView(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindDynamicMemoryView* pPacket = (struct_xglCmdBindDynamicMemoryView*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pMemView = (const XGL_MEMORY_VIEW_ATTACH_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMemView);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBindIndexData {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY mem;
+ XGL_GPU_SIZE offset;
+ XGL_INDEX_TYPE indexType;
+} struct_xglCmdBindIndexData;
+
+static struct_xglCmdBindIndexData* interpret_body_as_xglCmdBindIndexData(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindIndexData* pPacket = (struct_xglCmdBindIndexData*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBindAttachments {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_UINT colorAttachmentCount;
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments;
+ const XGL_DEPTH_STENCIL_BIND_INFO* pDepthAttachment;
+} struct_xglCmdBindAttachments;
+
+static struct_xglCmdBindAttachments* interpret_body_as_xglCmdBindAttachments(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBindAttachments* pPacket = (struct_xglCmdBindAttachments*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pColorAttachments = (const XGL_COLOR_ATTACHMENT_BIND_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pColorAttachments);
+ pPacket->pDepthAttachment = (const XGL_DEPTH_STENCIL_BIND_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pDepthAttachment);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdPrepareMemoryRegions {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_UINT transitionCount;
+ const XGL_MEMORY_STATE_TRANSITION* pStateTransitions;
+} struct_xglCmdPrepareMemoryRegions;
+
+static struct_xglCmdPrepareMemoryRegions* interpret_body_as_xglCmdPrepareMemoryRegions(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdPrepareMemoryRegions* pPacket = (struct_xglCmdPrepareMemoryRegions*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pStateTransitions = (const XGL_MEMORY_STATE_TRANSITION*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pStateTransitions);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdPrepareImages {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_UINT transitionCount;
+ const XGL_IMAGE_STATE_TRANSITION* pStateTransitions;
+} struct_xglCmdPrepareImages;
+
+static struct_xglCmdPrepareImages* interpret_body_as_xglCmdPrepareImages(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdPrepareImages* pPacket = (struct_xglCmdPrepareImages*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pStateTransitions = (const XGL_IMAGE_STATE_TRANSITION*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pStateTransitions);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDraw {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_UINT firstVertex;
+ XGL_UINT vertexCount;
+ XGL_UINT firstInstance;
+ XGL_UINT instanceCount;
+} struct_xglCmdDraw;
+
+static struct_xglCmdDraw* interpret_body_as_xglCmdDraw(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDraw* pPacket = (struct_xglCmdDraw*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDrawIndexed {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_UINT firstIndex;
+ XGL_UINT indexCount;
+ XGL_INT vertexOffset;
+ XGL_UINT firstInstance;
+ XGL_UINT instanceCount;
+} struct_xglCmdDrawIndexed;
+
+static struct_xglCmdDrawIndexed* interpret_body_as_xglCmdDrawIndexed(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDrawIndexed* pPacket = (struct_xglCmdDrawIndexed*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDrawIndirect {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY mem;
+ XGL_GPU_SIZE offset;
+ XGL_UINT32 count;
+ XGL_UINT32 stride;
+} struct_xglCmdDrawIndirect;
+
+static struct_xglCmdDrawIndirect* interpret_body_as_xglCmdDrawIndirect(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDrawIndirect* pPacket = (struct_xglCmdDrawIndirect*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDrawIndexedIndirect {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY mem;
+ XGL_GPU_SIZE offset;
+ XGL_UINT32 count;
+ XGL_UINT32 stride;
+} struct_xglCmdDrawIndexedIndirect;
+
+static struct_xglCmdDrawIndexedIndirect* interpret_body_as_xglCmdDrawIndexedIndirect(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDrawIndexedIndirect* pPacket = (struct_xglCmdDrawIndexedIndirect*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDispatch {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_UINT x;
+ XGL_UINT y;
+ XGL_UINT z;
+} struct_xglCmdDispatch;
+
+static struct_xglCmdDispatch* interpret_body_as_xglCmdDispatch(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDispatch* pPacket = (struct_xglCmdDispatch*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDispatchIndirect {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY mem;
+ XGL_GPU_SIZE offset;
+} struct_xglCmdDispatchIndirect;
+
+static struct_xglCmdDispatchIndirect* interpret_body_as_xglCmdDispatchIndirect(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDispatchIndirect* pPacket = (struct_xglCmdDispatchIndirect*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdCopyMemory {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY srcMem;
+ XGL_GPU_MEMORY destMem;
+ XGL_UINT regionCount;
+ const XGL_MEMORY_COPY* pRegions;
+} struct_xglCmdCopyMemory;
+
+static struct_xglCmdCopyMemory* interpret_body_as_xglCmdCopyMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdCopyMemory* pPacket = (struct_xglCmdCopyMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRegions = (const XGL_MEMORY_COPY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRegions);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdCopyImage {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE srcImage;
+ XGL_IMAGE destImage;
+ XGL_UINT regionCount;
+ const XGL_IMAGE_COPY* pRegions;
+} struct_xglCmdCopyImage;
+
+static struct_xglCmdCopyImage* interpret_body_as_xglCmdCopyImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdCopyImage* pPacket = (struct_xglCmdCopyImage*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRegions = (const XGL_IMAGE_COPY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRegions);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdCopyMemoryToImage {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY srcMem;
+ XGL_IMAGE destImage;
+ XGL_UINT regionCount;
+ const XGL_MEMORY_IMAGE_COPY* pRegions;
+} struct_xglCmdCopyMemoryToImage;
+
+static struct_xglCmdCopyMemoryToImage* interpret_body_as_xglCmdCopyMemoryToImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdCopyMemoryToImage* pPacket = (struct_xglCmdCopyMemoryToImage*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRegions = (const XGL_MEMORY_IMAGE_COPY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRegions);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdCopyImageToMemory {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE srcImage;
+ XGL_GPU_MEMORY destMem;
+ XGL_UINT regionCount;
+ const XGL_MEMORY_IMAGE_COPY* pRegions;
+} struct_xglCmdCopyImageToMemory;
+
+static struct_xglCmdCopyImageToMemory* interpret_body_as_xglCmdCopyImageToMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdCopyImageToMemory* pPacket = (struct_xglCmdCopyImageToMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRegions = (const XGL_MEMORY_IMAGE_COPY*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRegions);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdCloneImageData {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE srcImage;
+ XGL_IMAGE_STATE srcImageState;
+ XGL_IMAGE destImage;
+ XGL_IMAGE_STATE destImageState;
+} struct_xglCmdCloneImageData;
+
+static struct_xglCmdCloneImageData* interpret_body_as_xglCmdCloneImageData(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdCloneImageData* pPacket = (struct_xglCmdCloneImageData*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdUpdateMemory {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY destMem;
+ XGL_GPU_SIZE destOffset;
+ XGL_GPU_SIZE dataSize;
+ const XGL_UINT32* pData;
+} struct_xglCmdUpdateMemory;
+
+static struct_xglCmdUpdateMemory* interpret_body_as_xglCmdUpdateMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdUpdateMemory* pPacket = (struct_xglCmdUpdateMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pData = (const XGL_UINT32*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdFillMemory {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY destMem;
+ XGL_GPU_SIZE destOffset;
+ XGL_GPU_SIZE fillSize;
+ XGL_UINT32 data;
+} struct_xglCmdFillMemory;
+
+static struct_xglCmdFillMemory* interpret_body_as_xglCmdFillMemory(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdFillMemory* pPacket = (struct_xglCmdFillMemory*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdClearColorImage {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE image;
+ const XGL_FLOAT color[4];
+ XGL_UINT rangeCount;
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges;
+} struct_xglCmdClearColorImage;
+
+static struct_xglCmdClearColorImage* interpret_body_as_xglCmdClearColorImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdClearColorImage* pPacket = (struct_xglCmdClearColorImage*)pHeader->pBody;
+ pPacket->header = pHeader;
+// pPacket->color = (const XGL_FLOAT*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->color);
+ pPacket->pRanges = (const XGL_IMAGE_SUBRESOURCE_RANGE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRanges);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdClearColorImageRaw {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE image;
+ const XGL_UINT32 color[4];
+ XGL_UINT rangeCount;
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges;
+} struct_xglCmdClearColorImageRaw;
+
+static struct_xglCmdClearColorImageRaw* interpret_body_as_xglCmdClearColorImageRaw(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdClearColorImageRaw* pPacket = (struct_xglCmdClearColorImageRaw*)pHeader->pBody;
+ pPacket->header = pHeader;
+// pPacket->color = (const XGL_UINT32*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->color);
+ pPacket->pRanges = (const XGL_IMAGE_SUBRESOURCE_RANGE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRanges);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdClearDepthStencil {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE image;
+ XGL_FLOAT depth;
+ XGL_UINT8 stencil;
+ XGL_UINT rangeCount;
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges;
+} struct_xglCmdClearDepthStencil;
+
+static struct_xglCmdClearDepthStencil* interpret_body_as_xglCmdClearDepthStencil(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdClearDepthStencil* pPacket = (struct_xglCmdClearDepthStencil*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRanges = (const XGL_IMAGE_SUBRESOURCE_RANGE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRanges);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdResolveImage {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_IMAGE srcImage;
+ XGL_IMAGE destImage;
+ XGL_UINT rectCount;
+ const XGL_IMAGE_RESOLVE* pRects;
+} struct_xglCmdResolveImage;
+
+static struct_xglCmdResolveImage* interpret_body_as_xglCmdResolveImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdResolveImage* pPacket = (struct_xglCmdResolveImage*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pRects = (const XGL_IMAGE_RESOLVE*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pRects);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdSetEvent {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_EVENT event;
+} struct_xglCmdSetEvent;
+
+static struct_xglCmdSetEvent* interpret_body_as_xglCmdSetEvent(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdSetEvent* pPacket = (struct_xglCmdSetEvent*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdResetEvent {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_EVENT event;
+} struct_xglCmdResetEvent;
+
+static struct_xglCmdResetEvent* interpret_body_as_xglCmdResetEvent(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdResetEvent* pPacket = (struct_xglCmdResetEvent*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdMemoryAtomic {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_GPU_MEMORY destMem;
+ XGL_GPU_SIZE destOffset;
+ XGL_UINT64 srcData;
+ XGL_ATOMIC_OP atomicOp;
+} struct_xglCmdMemoryAtomic;
+
+static struct_xglCmdMemoryAtomic* interpret_body_as_xglCmdMemoryAtomic(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdMemoryAtomic* pPacket = (struct_xglCmdMemoryAtomic*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdBeginQuery {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_QUERY_POOL queryPool;
+ XGL_UINT slot;
+ XGL_FLAGS flags;
+} struct_xglCmdBeginQuery;
+
+static struct_xglCmdBeginQuery* interpret_body_as_xglCmdBeginQuery(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdBeginQuery* pPacket = (struct_xglCmdBeginQuery*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdEndQuery {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_QUERY_POOL queryPool;
+ XGL_UINT slot;
+} struct_xglCmdEndQuery;
+
+static struct_xglCmdEndQuery* interpret_body_as_xglCmdEndQuery(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdEndQuery* pPacket = (struct_xglCmdEndQuery*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdResetQueryPool {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_QUERY_POOL queryPool;
+ XGL_UINT startQuery;
+ XGL_UINT queryCount;
+} struct_xglCmdResetQueryPool;
+
+static struct_xglCmdResetQueryPool* interpret_body_as_xglCmdResetQueryPool(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdResetQueryPool* pPacket = (struct_xglCmdResetQueryPool*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdWriteTimestamp {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_TIMESTAMP_TYPE timestampType;
+ XGL_GPU_MEMORY destMem;
+ XGL_GPU_SIZE destOffset;
+} struct_xglCmdWriteTimestamp;
+
+static struct_xglCmdWriteTimestamp* interpret_body_as_xglCmdWriteTimestamp(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdWriteTimestamp* pPacket = (struct_xglCmdWriteTimestamp*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdInitAtomicCounters {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ XGL_UINT startCounter;
+ XGL_UINT counterCount;
+ const XGL_UINT32* pData;
+} struct_xglCmdInitAtomicCounters;
+
+static struct_xglCmdInitAtomicCounters* interpret_body_as_xglCmdInitAtomicCounters(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdInitAtomicCounters* pPacket = (struct_xglCmdInitAtomicCounters*)pHeader->pBody;
+ pPacket->header = pHeader;
+ pPacket->pData = (const XGL_UINT32*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdLoadAtomicCounters {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ XGL_UINT startCounter;
+ XGL_UINT counterCount;
+ XGL_GPU_MEMORY srcMem;
+ XGL_GPU_SIZE srcOffset;
+} struct_xglCmdLoadAtomicCounters;
+
+static struct_xglCmdLoadAtomicCounters* interpret_body_as_xglCmdLoadAtomicCounters(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdLoadAtomicCounters* pPacket = (struct_xglCmdLoadAtomicCounters*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglCmdSaveAtomicCounters {
+ glv_trace_packet_header* header;
+ XGL_CMD_BUFFER cmdBuffer;
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint;
+ XGL_UINT startCounter;
+ XGL_UINT counterCount;
+ XGL_GPU_MEMORY destMem;
+ XGL_GPU_SIZE destOffset;
+} struct_xglCmdSaveAtomicCounters;
+
+static struct_xglCmdSaveAtomicCounters* interpret_body_as_xglCmdSaveAtomicCounters(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdSaveAtomicCounters* pPacket = (struct_xglCmdSaveAtomicCounters*)pHeader->pBody;
+ pPacket->header = pHeader;
+ return pPacket;
+}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg.c b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg.c
new file mode 100644
index 0000000..01839b6
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg.c
@@ -0,0 +1,307 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glv_platform.h"
+#include "glvtrace_xgl_xgldbg.h"
+#include "glvtrace_xgl_xgldbg_structs.h"
+#include "glvtrace_xgl_packet_id.h"
+#include "glv_common.h"
+#ifdef WIN32
+#include "mhook/mhook-lib/mhook.h"
+#endif
+
+// ======================== Pointers to real functions ========================
+static XGL_RESULT( XGLAPI * real_xglDbgSetValidationLevel)(
+ XGL_DEVICE device,
+ XGL_VALIDATION_LEVEL validationLevel) = xglDbgSetValidationLevel;
+
+static XGL_RESULT( XGLAPI * real_xglDbgRegisterMsgCallback)(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ XGL_VOID* pUserData) = xglDbgRegisterMsgCallback;
+
+static XGL_RESULT( XGLAPI * real_xglDbgUnregisterMsgCallback)(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) = xglDbgUnregisterMsgCallback;
+
+static XGL_RESULT( XGLAPI * real_xglDbgSetMessageFilter)(
+ XGL_DEVICE device,
+ XGL_INT msgCode,
+ XGL_DBG_MSG_FILTER filter) = xglDbgSetMessageFilter;
+
+static XGL_RESULT( XGLAPI * real_xglDbgSetObjectTag)(
+ XGL_BASE_OBJECT object,
+ XGL_SIZE tagSize,
+ const XGL_VOID* pTag) = xglDbgSetObjectTag;
+
+static XGL_RESULT( XGLAPI * real_xglDbgSetGlobalOption)(
+ XGL_DBG_GLOBAL_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData) = xglDbgSetGlobalOption;
+
+static XGL_RESULT( XGLAPI * real_xglDbgSetDeviceOption)(
+ XGL_DEVICE device,
+ XGL_DBG_DEVICE_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData) = xglDbgSetDeviceOption;
+
+static XGL_VOID( XGLAPI * real_xglCmdDbgMarkerBegin)(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_CHAR* pMarker) = xglCmdDbgMarkerBegin;
+
+static XGL_VOID( XGLAPI * real_xglCmdDbgMarkerEnd)(
+ XGL_CMD_BUFFER cmdBuffer) = xglCmdDbgMarkerEnd;
+
+void AttachHooks_xgldbg()
+{
+ BOOL hookSuccess = TRUE;
+#if defined(WIN32)
+ Mhook_BeginMultiOperation(FALSE);
+ if (real_xglDbgSetValidationLevel != NULL)
+ {
+ hookSuccess = Mhook_SetHook((PVOID*)&real_xglDbgSetValidationLevel, hooked_xglDbgSetValidationLevel);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDbgRegisterMsgCallback, hooked_xglDbgRegisterMsgCallback);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDbgUnregisterMsgCallback, hooked_xglDbgUnregisterMsgCallback);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDbgSetMessageFilter, hooked_xglDbgSetMessageFilter);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDbgSetObjectTag, hooked_xglDbgSetObjectTag);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDbgSetGlobalOption, hooked_xglDbgSetGlobalOption);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglDbgSetDeviceOption, hooked_xglDbgSetDeviceOption);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDbgMarkerBegin, hooked_xglCmdDbgMarkerBegin);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglCmdDbgMarkerEnd, hooked_xglCmdDbgMarkerEnd);
+ }
+
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook XGLDbg.");
+ }
+
+ Mhook_EndMultiOperation();
+#elif defined(__linux__)
+ hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgSetValidationLevel, "xglDbgSetValidationLevel");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgRegisterMsgCallback, "xglDbgRegisterMsgCallback");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgUnregisterMsgCallback, "xglDbgUnregisterMsgCallback");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgSetMessageFilter, "xglDbgSetMessageFilter");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgSetObjectTag, "xglDbgSetObjectTag");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgSetGlobalOption,"xglDbgSetGlobalOption");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglDbgSetDeviceOption, "xglDbgSetDeviceOption");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDbgMarkerBegin, "xglCmdDbgMarkerBegin");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglCmdDbgMarkerEnd, "xglCmdDbgMarkerEnd");
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook XGLDbg.");
+ }
+#endif
+}
+
+void DetachHooks_xgldbg()
+{
+
+#ifdef WIN32
+ BOOL unhookSuccess = TRUE;
+
+ if (real_xglDbgSetValidationLevel != NULL)
+ {
+ unhookSuccess = Mhook_Unhook((PVOID*)&real_xglDbgSetValidationLevel);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDbgRegisterMsgCallback);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDbgUnregisterMsgCallback);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDbgSetMessageFilter);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDbgSetObjectTag);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDbgSetGlobalOption);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglDbgSetDeviceOption);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDbgMarkerBegin);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglCmdDbgMarkerEnd);
+ }
+
+ if (!unhookSuccess)
+ {
+ glv_LogError("Failed to unhook XGLDbg.");
+ }
+#elif defined(__linux__)
+ return;
+#endif
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgSetValidationLevel(
+ XGL_DEVICE device,
+ XGL_VALIDATION_LEVEL validationLevel)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgSetValidationLevel* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgSetValidationLevel);
+ CREATE_TRACE_PACKET(xglDbgSetValidationLevel, 0);
+ result = real_xglDbgSetValidationLevel(device, validationLevel);
+ pPacket = interpret_body_as_xglDbgSetValidationLevel(pHeader);
+ pPacket->device = device;
+ pPacket->validationLevel = validationLevel;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgRegisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ XGL_VOID* pUserData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgRegisterMsgCallback* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgRegisterMsgCallback);
+ CREATE_TRACE_PACKET(xglDbgRegisterMsgCallback, 0);
+ result = real_xglDbgRegisterMsgCallback(pfnMsgCallback, pUserData);
+ pPacket = interpret_body_as_xglDbgRegisterMsgCallback(pHeader);
+ pPacket->pfnMsgCallback = pfnMsgCallback;
+ pPacket->pUserData = pUserData;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgUnregisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgUnregisterMsgCallback* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgUnregisterMsgCallback);
+ CREATE_TRACE_PACKET(xglDbgUnregisterMsgCallback, 0);
+ result = real_xglDbgUnregisterMsgCallback(pfnMsgCallback);
+ pPacket = interpret_body_as_xglDbgUnregisterMsgCallback(pHeader);
+ pPacket->pfnMsgCallback = pfnMsgCallback;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgSetMessageFilter(
+ XGL_DEVICE device,
+ XGL_INT msgCode,
+ XGL_DBG_MSG_FILTER filter)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgSetMessageFilter* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgSetMessageFilter);
+ CREATE_TRACE_PACKET(xglDbgSetMessageFilter, 0);
+ result = real_xglDbgSetMessageFilter(device, msgCode, filter);
+ pPacket = interpret_body_as_xglDbgSetMessageFilter(pHeader);
+ pPacket->device = device;
+ pPacket->msgCode = msgCode;
+ pPacket->filter = filter;
+ pPacket->result = result;
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgSetObjectTag(
+ XGL_BASE_OBJECT object,
+ XGL_SIZE tagSize,
+ const XGL_VOID* pTag)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgSetObjectTag* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgSetObjectTag);
+ CREATE_TRACE_PACKET(xglDbgSetObjectTag, tagSize);
+ result = real_xglDbgSetObjectTag(object, tagSize, pTag);
+ pPacket = interpret_body_as_xglDbgSetObjectTag(pHeader);
+ pPacket->object = object;
+ pPacket->tagSize = tagSize;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pTag), tagSize, pTag);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pTag));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgSetGlobalOption(
+ XGL_DBG_GLOBAL_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgSetGlobalOption* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgSetGlobalOption);
+ CREATE_TRACE_PACKET(xglDbgSetGlobalOption, dataSize);
+ result = real_xglDbgSetGlobalOption(dbgOption, dataSize, pData);
+ pPacket = interpret_body_as_xglDbgSetGlobalOption(pHeader);
+ pPacket->dbgOption = dbgOption;
+ pPacket->dataSize = dataSize;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), dataSize, pData);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglDbgSetDeviceOption(
+ XGL_DEVICE device,
+ XGL_DBG_DEVICE_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglDbgSetDeviceOption* pPacket;
+ SEND_ENTRYPOINT_ID(xglDbgSetDeviceOption);
+ CREATE_TRACE_PACKET(xglDbgSetDeviceOption, dataSize);
+ result = real_xglDbgSetDeviceOption(device, dbgOption, dataSize, pData);
+ pPacket = interpret_body_as_xglDbgSetDeviceOption(pHeader);
+ pPacket->device = device;
+ pPacket->dbgOption = dbgOption;
+ pPacket->dataSize = dataSize;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pData), dataSize, pData);
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDbgMarkerBegin(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_CHAR* pMarker)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDbgMarkerBegin* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDbgMarkerBegin);
+ CREATE_TRACE_PACKET(xglCmdDbgMarkerBegin, strlen((const char *)pMarker) + 1);
+ real_xglCmdDbgMarkerBegin(cmdBuffer, pMarker);
+ pPacket = interpret_body_as_xglCmdDbgMarkerBegin(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMarker), strlen((const char *)pMarker) + 1, pMarker);
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMarker));
+ FINISH_TRACE_PACKET();
+}
+
+GLVTRACER_EXPORT XGL_VOID XGLAPI __HOOKED_xglCmdDbgMarkerEnd(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ glv_trace_packet_header* pHeader;
+ struct_xglCmdDbgMarkerEnd* pPacket;
+ SEND_ENTRYPOINT_ID(xglCmdDbgMarkerEnd);
+ CREATE_TRACE_PACKET(xglCmdDbgMarkerEnd, 0);
+ real_xglCmdDbgMarkerEnd(cmdBuffer);
+ pPacket = interpret_body_as_xglCmdDbgMarkerEnd(pHeader);
+ pPacket->cmdBuffer = cmdBuffer;
+ FINISH_TRACE_PACKET();
+}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg.h
new file mode 100644
index 0000000..e38cb1d
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg.h
@@ -0,0 +1,93 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "xgl/inc/xgl.h"
+#include "xgl/inc/xglDbg.h"
+
+void AttachHooks_xgldbg();
+void DetachHooks_xgldbg();
+
+#ifdef WIN32
+#define __HOOKED_xglDbgSetValidationLevel hooked_xglDbgSetValidationLevel
+#define __HOOKED_xglDbgRegisterMsgCallback hooked_xglDbgRegisterMsgCallback
+#define __HOOKED_xglDbgUnregisterMsgCallback hooked_xglDbgUnregisterMsgCallback
+#define __HOOKED_xglDbgSetMessageFilter hooked_xglDbgSetMessageFilter
+#define __HOOKED_xglDbgSetObjectTag hooked_xglDbgSetObjectTag
+#define __HOOKED_xglDbgSetGlobalOption hooked_xglDbgSetGlobalOption
+#define __HOOKED_xglDbgSetDeviceOption hooked_xglDbgSetDeviceOption
+#define __HOOKED_xglCmdDbgMarkerBegin hooked_xglCmdDbgMarkerBegin
+#define __HOOKED_xglCmdDbgMarkerEnd hooked_xglCmdDbgMarkerEnd
+#elif defined(__linux__)
+#define __HOOKED_xglDbgSetValidationLevel xglDbgSetValidationLevel
+#define __HOOKED_xglDbgRegisterMsgCallback xglDbgRegisterMsgCallback
+#define __HOOKED_xglDbgUnregisterMsgCallback xglDbgUnregisterMsgCallback
+#define __HOOKED_xglDbgSetMessageFilter xglDbgSetMessageFilter
+#define __HOOKED_xglDbgSetObjectTag xglDbgSetObjectTag
+#define __HOOKED_xglDbgSetGlobalOption xglDbgSetGlobalOption
+#define __HOOKED_xglDbgSetDeviceOption xglDbgSetDeviceOption
+#define __HOOKED_xglCmdDbgMarkerBegin xglCmdDbgMarkerBegin
+#define __HOOKED_xglCmdDbgMarkerEnd xglCmdDbgMarkerEnd
+#endif
+
+//================== hooked function declarations =============================
+XGL_RESULT XGLAPI __HOOKED_xglDbgSetValidationLevel(
+ XGL_DEVICE device,
+ XGL_VALIDATION_LEVEL validationLevel);
+
+XGL_RESULT XGLAPI __HOOKED_xglDbgRegisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ XGL_VOID* pUserData);
+
+XGL_RESULT XGLAPI __HOOKED_xglDbgUnregisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
+
+XGL_RESULT XGLAPI __HOOKED_xglDbgSetMessageFilter(
+ XGL_DEVICE device,
+ XGL_INT msgCode,
+ XGL_DBG_MSG_FILTER filter);
+
+XGL_RESULT XGLAPI __HOOKED_xglDbgSetObjectTag(
+ XGL_BASE_OBJECT object,
+ XGL_SIZE tagSize,
+ const XGL_VOID* pTag);
+
+XGL_RESULT XGLAPI __HOOKED_xglDbgSetGlobalOption(
+ XGL_DBG_GLOBAL_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData);
+
+XGL_RESULT XGLAPI __HOOKED_xglDbgSetDeviceOption(
+ XGL_DEVICE device,
+ XGL_DBG_DEVICE_OPTION dbgOption,
+ XGL_SIZE dataSize,
+ const XGL_VOID* pData);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDbgMarkerBegin(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_CHAR* pMarker);
+
+XGL_VOID XGLAPI __HOOKED_xglCmdDbgMarkerEnd(
+ XGL_CMD_BUFFER cmdBuffer);
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg_structs.h
new file mode 100644
index 0000000..5f0ef88
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xgldbg_structs.h
@@ -0,0 +1,162 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "xgl/inc/xglDbg.h"
+#include "glv_trace_packet_utils.h"
+
+//=============================================================================
+// entrypoints
+
+typedef struct struct_xglDbgSetValidationLevel {
+ glv_trace_packet_header* pHeader;
+ XGL_DEVICE device;
+ XGL_VALIDATION_LEVEL validationLevel;
+ XGL_RESULT result;
+} struct_xglDbgSetValidationLevel;
+
+static struct_xglDbgSetValidationLevel* interpret_body_as_xglDbgSetValidationLevel(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgSetValidationLevel* pPacket = (struct_xglDbgSetValidationLevel*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglDbgRegisterMsgCallback{
+ glv_trace_packet_header* pHeader;
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback;
+ XGL_VOID* pUserData;
+ XGL_RESULT result;
+} struct_xglDbgRegisterMsgCallback;
+
+static struct_xglDbgRegisterMsgCallback* interpret_body_as_xglDbgRegisterMsgCallback(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgRegisterMsgCallback* pPacket = (struct_xglDbgRegisterMsgCallback*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglDbgUnregisterMsgCallback{
+ glv_trace_packet_header* pHeader;
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback;
+ XGL_RESULT result;
+} struct_xglDbgUnregisterMsgCallback;
+
+static struct_xglDbgUnregisterMsgCallback* interpret_body_as_xglDbgUnregisterMsgCallback(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgUnregisterMsgCallback* pPacket = (struct_xglDbgUnregisterMsgCallback*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglDbgSetMessageFilter{
+ glv_trace_packet_header* pHeader;
+ XGL_DEVICE device;
+ XGL_INT msgCode;
+ XGL_DBG_MSG_FILTER filter;
+ XGL_RESULT result;
+} struct_xglDbgSetMessageFilter;
+
+static struct_xglDbgSetMessageFilter* interpret_body_as_xglDbgSetMessageFilter(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgSetMessageFilter* pPacket = (struct_xglDbgSetMessageFilter*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ return pPacket;
+}
+
+typedef struct struct_xglDbgSetObjectTag{
+ glv_trace_packet_header* pHeader;
+ XGL_BASE_OBJECT object;
+ XGL_SIZE tagSize;
+ const XGL_VOID* pTag;
+ XGL_RESULT result;
+} struct_xglDbgSetObjectTag;
+
+static struct_xglDbgSetObjectTag* interpret_body_as_xglDbgSetObjectTag(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgSetObjectTag* pPacket = (struct_xglDbgSetObjectTag*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pTag = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pTag);
+ return pPacket;
+}
+
+typedef struct struct_xglDbgSetGlobalOption{
+ glv_trace_packet_header* pHeader;
+ XGL_DBG_GLOBAL_OPTION dbgOption;
+ XGL_SIZE dataSize;
+ const XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglDbgSetGlobalOption;
+
+static struct_xglDbgSetGlobalOption* interpret_body_as_xglDbgSetGlobalOption(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgSetGlobalOption* pPacket = (struct_xglDbgSetGlobalOption*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pData = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglDbgSetDeviceOption{
+ glv_trace_packet_header* pHeader;
+ XGL_DEVICE device;
+ XGL_DBG_DEVICE_OPTION dbgOption;
+ XGL_SIZE dataSize;
+ const XGL_VOID* pData;
+ XGL_RESULT result;
+} struct_xglDbgSetDeviceOption;
+
+static struct_xglDbgSetDeviceOption* interpret_body_as_xglDbgSetDeviceOption(glv_trace_packet_header* pHeader)
+{
+ struct_xglDbgSetDeviceOption* pPacket = (struct_xglDbgSetDeviceOption*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pData = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pData);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDbgMarkerBegin{
+ glv_trace_packet_header* pHeader;
+ XGL_CMD_BUFFER cmdBuffer;
+ const XGL_CHAR* pMarker;
+} struct_xglCmdDbgMarkerBegin;
+
+static struct_xglCmdDbgMarkerBegin* interpret_body_as_xglCmdDbgMarkerBegin(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDbgMarkerBegin* pPacket = (struct_xglCmdDbgMarkerBegin*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pMarker = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMarker);
+ return pPacket;
+}
+
+typedef struct struct_xglCmdDbgMarkerEnd{
+ glv_trace_packet_header* pHeader;
+ XGL_CMD_BUFFER cmdBuffer;
+} struct_xglCmdDbgMarkerEnd;
+
+static struct_xglCmdDbgMarkerEnd* interpret_body_as_xglCmdDbgMarkerEnd(glv_trace_packet_header* pHeader)
+{
+ struct_xglCmdDbgMarkerEnd* pPacket = (struct_xglCmdDbgMarkerEnd*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ return pPacket;
+}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext.c b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext.c
new file mode 100644
index 0000000..1b250a8
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext.c
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2014, Lunarg, Inc. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 "glv_platform.h"
+#include "glvtrace_xgl_xglwsix11ext.h"
+#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glvtrace_xgl_packet_id.h"
+#include "glv_common.h"
+#ifdef WIN32
+#include "mhook/mhook-lib/mhook.h"
+#endif
+
+// ======================== Pointers to real functions ========================
+static XGL_RESULT ( XGLAPI * real_xglWsiX11AssociateConnection)(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo) = xglWsiX11AssociateConnection;
+
+static XGL_RESULT ( XGLAPI * real_xglWsiX11GetMSC)(
+ XGL_DEVICE device,
+ xcb_randr_crtc_t crtc,
+ XGL_UINT64* pMsc) = xglWsiX11GetMSC;
+
+static XGL_RESULT ( XGLAPI * real_xglWsiX11CreatePresentableImage)(
+ XGL_DEVICE device,
+ const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem) = xglWsiX11CreatePresentableImage;
+
+static XGL_RESULT ( XGLAPI * real_xglWsiX11QueuePresent)(
+ XGL_QUEUE queue,
+ const XGL_WSI_X11_PRESENT_INFO* pPresentInfo,
+ XGL_FENCE fence) = xglWsiX11QueuePresent;
+
+void AttachHooks_xglwsix11ext()
+{
+ BOOL hookSuccess = TRUE;
+#if defined(WIN32)
+ Mhook_BeginMultiOperation(FALSE);
+ if (real_xglWsiX11AssociateConnection != NULL)
+ {
+ hookSuccess = Mhook_SetHook((PVOID*)&real_xglWsiX11AssociateConnection, hooked_xglWsiX11AssociateConnection);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglWsiX11GetMSC, hooked_xglWsiX11GetMSC);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglWsiX11CreatePresentableImage, hooked_xglWsiX11CreatePresentableImage);
+ hookSuccess &= Mhook_SetHook((PVOID*)&real_xglWsiX11QueuePresent, hooked_xglWsiX11QueuePresent);
+ }
+
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook XGLWsiX11Ext.");
+ }
+
+ Mhook_EndMultiOperation();
+#elif defined(__linux__)
+ hookSuccess = glv_platform_get_next_lib_sym((PVOID*)&real_xglWsiX11AssociateConnection, "xglWsiX11AssociateConnection");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglWsiX11GetMSC, "xglWsiX11GetMSC");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglWsiX11CreatePresentableImage, "xglWsiX11CreatePresentableImage");
+ hookSuccess &= glv_platform_get_next_lib_sym((PVOID*)&real_xglWsiX11QueuePresent, "xglWsiX11QueuePresent");
+ if (!hookSuccess)
+ {
+ glv_LogError("Failed to hook XGLWsiX11Ext.");
+ }
+#endif
+}
+
+void DetachHooks_xglwsix11ext()
+{
+
+#ifdef WIN32
+ BOOL unhookSuccess = TRUE;
+
+ if (real_xglWsiX11AssociateConnection != NULL)
+ {
+ unhookSuccess = Mhook_Unhook((PVOID*)&real_real_xglWsiX11AssociateConnection);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglWsiX11GetMSC);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglWsiX11CreatePresentableImage);
+ unhookSuccess &= Mhook_Unhook((PVOID*)&real_xglWsiX11QueuePresent);
+ }
+ if (!unhookSuccess)
+ {
+ glv_LogError("Failed to unhook XGLWsiX11Ext.");
+ }
+#elif defined(__linux__)
+ return;
+#endif
+}
+
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglWsiX11AssociateConnection(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglWsiX11AssociateConnection* pPacket;
+ SEND_ENTRYPOINT_ID(xglWsiX11AssociateConnection);
+ CREATE_TRACE_PACKET(xglWsiX11AssociateConnection, sizeof(XGL_WSI_X11_CONNECTION_INFO) +
+ ((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0));
+ // TODO xcb_connection_t is opaque struct hope it is a pointer so sizeof(void *) = sizeof(xcb_connection_t)
+ result = real_xglWsiX11AssociateConnection(gpu, pConnectionInfo);
+ pPacket = interpret_body_as_xglWsiX11AssociateConnection(pHeader);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pConnectionInfo), sizeof(XGL_WSI_X11_CONNECTION_INFO), pConnectionInfo);
+ if (pConnectionInfo->pConnection != NULL) {
+ glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);
+ glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));
+ }
+ pPacket->gpu = gpu;
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pConnectionInfo));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglWsiX11GetMSC(
+ XGL_DEVICE device,
+ xcb_randr_crtc_t crtc,
+ XGL_UINT64* pMsc)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglWsiX11GetMSC* pPacket;
+ SEND_ENTRYPOINT_ID(xglWsiX11GetMSC);
+ CREATE_TRACE_PACKET(xglWsiX11GetMSC, sizeof(XGL_UINT64));
+ result = real_xglWsiX11GetMSC(device, crtc, pMsc);
+ pPacket = interpret_body_as_xglWsiX11GetMSC(pHeader);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMsc), sizeof(XGL_UINT64), pMsc);
+ pPacket->device = device;
+ pPacket->crtc = crtc;
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMsc));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglWsiX11CreatePresentableImage(
+ XGL_DEVICE device,
+ const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglWsiX11CreatePresentableImage* pPacket;
+ SEND_ENTRYPOINT_ID(xglWsiX11CreatePresentableImage);
+ CREATE_TRACE_PACKET(xglWsiX11CreatePresentableImage, sizeof(XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO) +
+ sizeof(XGL_IMAGE) + sizeof(XGL_GPU_MEMORY));
+ result = real_xglWsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
+ pPacket = interpret_body_as_xglWsiX11CreatePresentableImage(pHeader);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), pCreateInfo);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pImage), sizeof(XGL_IMAGE), pImage);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(XGL_GPU_MEMORY), pMem);
+ pPacket->device = device;
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImage));
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
+GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglWsiX11QueuePresent(
+ XGL_QUEUE queue,
+ const XGL_WSI_X11_PRESENT_INFO* pPresentInfo,
+ XGL_FENCE fence)
+{
+ glv_trace_packet_header* pHeader;
+ XGL_RESULT result;
+ struct_xglWsiX11QueuePresent* pPacket;
+ SEND_ENTRYPOINT_ID(xglWsiX11QueuePresent);
+ CREATE_TRACE_PACKET(xglWsiX11QueuePresent, sizeof(XGL_WSI_X11_PRESENT_INFO));
+ result = real_xglWsiX11QueuePresent(queue, pPresentInfo, fence);
+ pPacket = interpret_body_as_xglWsiX11QueuePresent(pHeader);
+ glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPresentInfo), sizeof(XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO), pPresentInfo);
+ pPacket->queue = queue;
+ pPacket->fence = fence;
+ pPacket->result = result;
+ glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pPresentInfo));
+ FINISH_TRACE_PACKET();
+ return result;
+}
+
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext.h
new file mode 100644
index 0000000..79344a3
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2014, Lunarg, Inc. 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.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+#pragma once
+
+#include "xgl/inc/xgl.h"
+#include "xgl/inc/xglWsiX11Ext.h"
+void AttachHooks_xglwsix11ext();
+void DetachHooks_xglwsix11ext();
+
+#ifdef WIN32
+#define __HOOKED_xglWsiX11AssociateConnection hooked_xglWsiX11AssociateConnection
+#define __HOOKED_xglWsiX11GetMSC hooked_xglWsiX11GetMSC
+#define __HOOKED_xglWsiX11CreatePresentableImage hooked_xglWsiX11CreatePresentableImage
+#define __HOOKED_xglWsiX11QueuePresent hooked_xglWsiX11QueuePresent
+#elif defined(__linux__)
+#define __HOOKED_xglWsiX11AssociateConnection xglWsiX11AssociateConnection
+#define __HOOKED_xglWsiX11GetMSC xglWsiX11GetMSC
+#define __HOOKED_xglWsiX11CreatePresentableImage xglWsiX11CreatePresentableImage
+#define __HOOKED_xglWsiX11QueuePresent xglWsiX11QueuePresent
+#endif
+
+//================== hooked function declarations =============================
+XGL_RESULT XGLAPI __HOOKED_xglWsiX11AssociateConnection(
+ XGL_PHYSICAL_GPU gpu,
+ const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo);
+
+XGL_RESULT XGLAPI __HOOKED_xglWsiX11GetMSC(
+ XGL_DEVICE device,
+ xcb_randr_crtc_t crtc,
+ XGL_UINT64* pMsc);
+
+XGL_RESULT XGLAPI __HOOKED_xglWsiX11CreatePresentableImage(
+ XGL_DEVICE device,
+ const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem);
+
+XGL_RESULT XGLAPI __HOOKED_xglWsiX11QueuePresent(
+ XGL_QUEUE queue,
+ const XGL_WSI_X11_PRESENT_INFO* pPresentInfo,
+ XGL_FENCE fence);
+
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext_structs.h
new file mode 100644
index 0000000..ddb98ce
--- /dev/null
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/glvtrace_xgl_xglwsix11ext_structs.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2014, Lunarg, Inc. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+#pragma once
+
+#include "xgl/inc/xglWsiX11Ext.h"
+#include "glv_trace_packet_utils.h"
+
+//=============================================================================
+// entrypoints
+
+typedef struct struct_xglWsiX11AssociateConnection {
+ glv_trace_packet_header* pHeader;
+ XGL_PHYSICAL_GPU gpu;
+ const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo;
+ XGL_RESULT result;
+} struct_xglWsiX11AssociateConnection;
+
+static struct_xglWsiX11AssociateConnection* interpret_body_as_xglWsiX11AssociateConnection(glv_trace_packet_header* pHeader)
+{
+ struct_xglWsiX11AssociateConnection* pPacket = (struct_xglWsiX11AssociateConnection*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pConnectionInfo = (const XGL_WSI_X11_CONNECTION_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pConnectionInfo);
+ return pPacket;
+}
+
+typedef struct struct_xglWsiX11CreatePresentableImage{
+ glv_trace_packet_header* pHeader;
+ XGL_DEVICE device;
+ const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo;
+ XGL_IMAGE* pImage;
+ XGL_GPU_MEMORY* pMem;
+ XGL_RESULT result;
+} struct_xglWsiX11CreatePresentableImage;
+
+static struct_xglWsiX11CreatePresentableImage* interpret_body_as_xglWsiX11CreatePresentableImage(glv_trace_packet_header* pHeader)
+{
+ struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pCreateInfo = (const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo);
+ pPacket->pImage = (XGL_IMAGE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pImage);
+ pPacket->pMem = (XGL_GPU_MEMORY*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMem);
+ return pPacket;
+}
+
+typedef struct struct_xglWsiX11GetMSC{
+ glv_trace_packet_header* pHeader;
+ XGL_DEVICE device;
+ xcb_randr_crtc_t crtc;
+ XGL_UINT64* pMsc;
+ XGL_RESULT result;
+} struct_xglWsiX11GetMSC;
+
+static struct_xglWsiX11GetMSC* interpret_body_as_xglWsiX11GetMSC(glv_trace_packet_header* pHeader)
+{
+ struct_xglWsiX11GetMSC* pPacket = (struct_xglWsiX11GetMSC*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pMsc = (XGL_UINT64*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pMsc);
+ return pPacket;
+}
+
+typedef struct struct_xglWsiX11QueuePresent{
+ glv_trace_packet_header* pHeader;
+ XGL_QUEUE queue;
+ const XGL_WSI_X11_PRESENT_INFO* pPresentInfo;
+ XGL_FENCE fence;
+ XGL_RESULT result;
+} struct_xglWsiX11QueuePresent;
+
+static struct_xglWsiX11QueuePresent* interpret_body_as_xglWsiX11QueuePresent(glv_trace_packet_header* pHeader)
+{
+ struct_xglWsiX11QueuePresent* pPacket = (struct_xglWsiX11QueuePresent*)pHeader->pBody;
+ pPacket->pHeader = pHeader;
+ pPacket->pPresentInfo = (const XGL_WSI_X11_PRESENT_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pPresentInfo);
+ return pPacket;
+}
diff --git a/tools/glave/src/glvcommon/CMakeLists.txt b/tools/glave/src/glvcommon/CMakeLists.txt
new file mode 100644
index 0000000..5b3c706
--- /dev/null
+++ b/tools/glave/src/glvcommon/CMakeLists.txt
@@ -0,0 +1,50 @@
+project(glvcommon)
+cmake_minimum_required(VERSION 2.8)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/thirdparty
+)
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ require_pthreads()
+endif()
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glv_filelike.c
+ glv_interconnect.c
+ glv_platform.c
+ glv_process.c
+ glv_settings.c
+ glv_tracelog.c
+ glv_trace_packet_utils.c
+)
+
+set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
+
+file( GLOB_RECURSE HDRS *.[h|inl] )
+
+if (NOT MSVC)
+ add_compiler_flag("-fPIC")
+endif()
+
+add_library(${PROJECT_NAME} ${SRC_LIST} ${HDRS})
+
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+target_link_libraries(${PROJECT_NAME}
+ Rpcrt4.lib
+)
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+target_link_Libraries(${PROJECT_NAME}
+ dl
+ pthread
+)
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+
+build_options_finalize()
+
+set_target_properties(glvcommon PROPERTIES LINKER_LANGUAGE C)
diff --git a/tools/glave/src/glvcommon/glv_common.h b/tools/glave/src/glvcommon/glv_common.h
new file mode 100644
index 0000000..24b1b70
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_common.h
@@ -0,0 +1,55 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#pragma once
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "glv_platform.h"
+
+#include "glv_memory.h"
+#include "glv_tracelog.h"
+
+#if defined(WIN32)
+
+#define GLVTRACER_EXPORT __declspec(dllexport)
+#define GLVTRACER_STDCALL __stdcall
+#define GLVTRACER_EXIT void __cdecl
+#define GLVTRACER_ENTRY void
+#define GLVTRACER_LEAVE void
+
+#elif defined(PLATFORM_LINUX)
+
+#define GLVTRACER_EXPORT __attribute__ ((visibility ("default")))
+#define GLVTRACER_STDCALL
+#define GLVTRACER_EXIT void
+#define GLVTRACER_ENTRY void __attribute__ ((constructor))
+#define GLVTRACER_LEAVE void __attribute__ ((destructor))
+
+#endif
diff --git a/tools/glave/src/glvcommon/glv_filelike.c b/tools/glave/src/glvcommon/glv_filelike.c
new file mode 100644
index 0000000..28a7964
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_filelike.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 "glv_filelike.h"
+#include "glv_common.h"
+#include "glv_interconnect.h"
+#include <assert.h>
+#include <stdlib.h>
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+Checkpoint* glv_Checkpoint_create(const char* _str)
+{
+ Checkpoint* pCheckpoint = GLV_NEW(Checkpoint);
+ pCheckpoint->mToken = _str;
+ pCheckpoint->mTokenLength = strlen(_str) + 1;
+ return pCheckpoint;
+}
+
+// ------------------------------------------------------------------------------------------------
+void glv_Checkpoint_write(Checkpoint* pCheckpoint, FileLike* _out)
+{
+ glv_FileLike_Write(_out, pCheckpoint->mToken, pCheckpoint->mTokenLength);
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_Checkpoint_read(Checkpoint* pCheckpoint, FileLike* _in)
+{
+ if (pCheckpoint->mTokenLength < 64) {
+ char buffer[64];
+ glv_FileLike_Read(_in, buffer, pCheckpoint->mTokenLength);
+ if (strcmp(buffer, pCheckpoint->mToken) != 0) {
+ return FALSE;
+ }
+ } else {
+ char* buffer = GLV_NEW_ARRAY(char, pCheckpoint->mTokenLength);
+ glv_FileLike_Read(_in, buffer, pCheckpoint->mTokenLength);
+ if (strcmp(buffer, pCheckpoint->mToken) != 0) {
+ GLV_DELETE(buffer);
+ return FALSE;
+ }
+ GLV_DELETE(buffer);
+ }
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+FileLike* glv_FileLike_create_file(FILE* fp)
+{
+ FileLike* pFile = NULL;
+ if (fp != NULL)
+ {
+ pFile = GLV_NEW(FileLike);
+ pFile->mMode = File;
+ pFile->mFile = fp;
+ pFile->mMessageStream = NULL;
+ }
+ return pFile;
+}
+
+// ------------------------------------------------------------------------------------------------
+FileLike* glv_FileLike_create_msg(MessageStream* _msgStream)
+{
+ FileLike* pFile = NULL;
+ if (_msgStream != NULL)
+ {
+ pFile = GLV_NEW(FileLike);
+ pFile->mMode = Socket;
+ pFile->mFile = NULL;
+ pFile->mMessageStream = _msgStream;
+ }
+ return pFile;
+}
+
+// ------------------------------------------------------------------------------------------------
+size_t glv_FileLike_Read(FileLike* pFileLike, void* _bytes, size_t _len)
+{
+ size_t bytesInStream = 0;
+ if (glv_FileLike_ReadRaw(pFileLike, &bytesInStream, sizeof(bytesInStream)) == FALSE)
+ return 0;
+
+ if (bytesInStream > 0) {
+ assert(_len >= bytesInStream);
+ if (glv_FileLike_ReadRaw(pFileLike, _bytes, min(_len, bytesInStream)) == FALSE)
+ return 0;
+ }
+
+ return min(_len, bytesInStream);
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_FileLike_ReadRaw(FileLike* pFileLike, void* _bytes, size_t _len)
+{
+ BOOL result = TRUE;
+ assert((pFileLike->mFile != 0) ^ (pFileLike->mMessageStream != 0));
+
+ switch(pFileLike->mMode) {
+ case File:
+ {
+ if (1 != fread(_bytes, _len, 1, pFileLike->mFile))
+ {
+ if (ferror(pFileLike->mFile) != 0)
+ {
+ perror("fread error");
+ }
+ else if (feof(pFileLike->mFile) != 0)
+ {
+ glv_LogWarn("Reached end of file\n");
+ }
+ result = FALSE;
+ }
+ break;
+ }
+ case Socket:
+ {
+ result = glv_MessageStream_BlockingRecv(pFileLike->mMessageStream, _bytes, _len);
+ break;
+ }
+
+ default:
+ assert(!"Invalid mode in FileLike_ReadRaw");
+ result = FALSE;
+ }
+ return result;
+}
+
+void glv_FileLike_Write(FileLike* pFileLike, const void* _bytes, size_t _len)
+{
+ glv_FileLike_WriteRaw(pFileLike, &_len, sizeof(_len));
+ if (_len) {
+ glv_FileLike_WriteRaw(pFileLike, _bytes, _len);
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_FileLike_WriteRaw(FileLike* pFile, const void* _bytes, size_t _len)
+{
+ BOOL result = TRUE;
+ assert((pFile->mFile != 0) ^ (pFile->mMessageStream != 0));
+ switch (pFile->mMode)
+ {
+ case File:
+ if (1 != fwrite(_bytes, _len, 1, pFile->mFile))
+ {
+ result = FALSE;
+ }
+ break;
+ case Socket:
+ result = glv_MessageStream_Send(pFile->mMessageStream, _bytes, _len);
+ break;
+ default:
+ assert(!"Invalid mode in FileLike_WriteRaw");
+ result = FALSE;
+ break;
+ }
+ return result;
+}
diff --git a/tools/glave/src/glvcommon/glv_filelike.h b/tools/glave/src/glvcommon/glv_filelike.h
new file mode 100644
index 0000000..bec2f8d
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_filelike.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+
+#pragma once
+
+#ifdef WIN32
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#pragma comment (lib, "Ws2_32.lib")
+#endif
+
+#include "glv_common.h"
+#include "glv_interconnect.h"
+
+typedef struct MessageStream MessageStream;
+
+struct FileLike;
+typedef struct FileLike FileLike;
+typedef struct FileLike
+{
+ enum { File, Socket } mMode;
+ FILE* mFile;
+ MessageStream* mMessageStream;
+} FileLike;
+
+// For creating checkpoints (consistency checks) in the various streams we're interacting with.
+typedef struct Checkpoint
+{
+ const char* mToken;
+ size_t mTokenLength;
+} Checkpoint;
+
+Checkpoint* glv_Checkpoint_create(const char* _str);
+void glv_Checkpoint_write(Checkpoint* pCheckpoint, FileLike* _out);
+BOOL glv_Checkpoint_read(Checkpoint* pCheckpoint, FileLike* _in);
+
+// An interface for interacting with sockets, files, and memory streams with a file-like interface.
+// This is a simple file-like interface--it doesn't support rewinding or anything fancy, just fifo
+// reads and writes.
+
+// create a filelike interface for file streaming
+FileLike* glv_FileLike_create_file(FILE* fp);
+
+// create a filelike interface for network streaming
+FileLike* glv_FileLike_create_msg(MessageStream* _msgStream);
+
+// read a size and then a buffer of that size
+size_t glv_FileLike_Read(FileLike* pFileLike, void* _bytes, size_t _len);
+
+// Normally, Read expects the size to live in the stream prefixing the data to be read.
+// With ReadRaw, no size is expected first, and the bytes are directly read.
+BOOL glv_FileLike_ReadRaw(FileLike* pFileLike, void* _bytes, size_t _len);
+
+// write _len and then the buffer of size _len
+void glv_FileLike_Write(FileLike* pFileLike, const void* _bytes, size_t _len);
+
+// Normally, Write outputs the _len to the stream first--with WriteRaw the bytes are simply written,
+// no size parameter first.
+BOOL glv_FileLike_WriteRaw(FileLike* pFile, const void* _bytes, size_t _len);
diff --git a/tools/glave/src/glvcommon/glv_interconnect.c b/tools/glave/src/glvcommon/glv_interconnect.c
new file mode 100644
index 0000000..5db7c1d
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_interconnect.c
@@ -0,0 +1,498 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 "glv_interconnect.h"
+#include "glv_common.h"
+
+#include "glv_filelike.h"
+
+const size_t kSendBufferSize = 1024 * 1024;
+
+MessageStream* gMessageStream = NULL;
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// private functions
+BOOL glv_MessageStream_SetupSocket(MessageStream* pStream);
+BOOL glv_MessageStream_SetupHostSocket(MessageStream* pStream);
+BOOL glv_MessageStream_SetupClientSocket(MessageStream* pStream);
+BOOL glv_MessageStream_Handshake(MessageStream* pStream);
+BOOL glv_MessageStream_ReallySend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional);
+void glv_MessageStream_FlushSendBuffer(MessageStream* pStream, BOOL _optional);
+
+// public functions
+MessageStream* glv_MessageStream_create_port_string(BOOL _isHost, const char* _address, const char* _port)
+{
+ MessageStream* pStream;
+ // make sure the strings are shorter than the destination buffer we have to store them!
+ assert(strlen(_address) + 1 <= 64);
+ assert(strlen(_port) + 1 <= 8);
+
+ pStream = GLV_NEW(MessageStream);
+ memcpy(pStream->mAddress, _address, strlen(_address) + 1);
+ memcpy(pStream->mPort, _port, strlen(_port) + 1);
+
+ pStream->mErrorNum = 0;
+ memset(pStream->mSmallBuffer, 0, 64);
+ pStream->mHost = _isHost;
+ pStream->mHostAddressInfo = NULL;
+ pStream->mNextPacketId = 0;
+ pStream->mSocket = INVALID_SOCKET;
+ pStream->mSendBuffer = NULL;
+
+ if (glv_MessageStream_SetupSocket(pStream) == FALSE)
+ {
+ pStream->mErrorNum = GLV_WSAGetLastError();
+ }
+
+ return pStream;
+}
+
+MessageStream* glv_MessageStream_create(BOOL _isHost, const char* _address, unsigned int _port)
+{
+ char portBuf[32];
+ memset(portBuf, 0, 32 * sizeof(char));
+ sprintf(portBuf, "%u", _port);
+ return glv_MessageStream_create_port_string(_isHost, _address, portBuf);
+}
+
+void glv_MessageStream_destroy(MessageStream** ppStream)
+{
+ if ((*ppStream)->mSendBuffer != NULL) {
+ // Try to get our data out.
+ glv_MessageStream_FlushSendBuffer(*ppStream, TRUE);
+ glv_SimpleBuffer_destroy(&(*ppStream)->mSendBuffer);
+ }
+
+ if ((*ppStream)->mHostAddressInfo != NULL)
+ {
+ freeaddrinfo((*ppStream)->mHostAddressInfo);
+ (*ppStream)->mHostAddressInfo = NULL;
+ }
+
+#if defined(WIN32)
+ WSACleanup();
+#endif
+ GLV_DELETE(*ppStream);
+ (*ppStream) = NULL;
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// private function implementations
+BOOL glv_MessageStream_SetupSocket(MessageStream* pStream)
+{
+ BOOL result = TRUE;
+#if defined(WIN32)
+ WSADATA wsaData;
+
+ if (WSAStartup(MAKEWORD(2, 2), &wsaData) != NO_ERROR) {
+ result = FALSE;
+ }
+ else
+#endif
+ {
+ if (pStream->mHost) {
+ result = glv_MessageStream_SetupHostSocket(pStream);
+ } else {
+ result = glv_MessageStream_SetupClientSocket(pStream);
+ }
+ }
+ return result;
+}
+
+BOOL glv_MessageStream_SetupHostSocket(MessageStream* pStream)
+{
+ int hr = 0;
+#ifdef PLATFORM_LINUX
+ int yes = 1;
+#endif
+ struct addrinfo hostAddrInfo = { 0 };
+ SOCKET listenSocket;
+
+ hostAddrInfo.ai_family = AF_INET;
+ hostAddrInfo.ai_socktype = SOCK_STREAM;
+ hostAddrInfo.ai_protocol = IPPROTO_TCP;
+ hostAddrInfo.ai_flags = AI_PASSIVE;
+
+ hr = getaddrinfo(NULL, pStream->mPort, &hostAddrInfo, &pStream->mHostAddressInfo);
+ if (hr != 0) {
+ glv_LogError("Host: Failed getaddrinfo\n");
+ return FALSE;
+ }
+
+ listenSocket = socket(pStream->mHostAddressInfo->ai_family, pStream->mHostAddressInfo->ai_socktype, pStream->mHostAddressInfo->ai_protocol);
+ if (listenSocket == INVALID_SOCKET) {
+ // TODO: Figure out errors
+ glv_LogError("Host: Failed creating a listen socket\n");
+ freeaddrinfo(pStream->mHostAddressInfo);
+ pStream->mHostAddressInfo = NULL;
+ return FALSE;
+ }
+
+#ifdef PLATFORM_LINUX
+ setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
+#endif
+ hr = bind(listenSocket, pStream->mHostAddressInfo->ai_addr, (int)pStream->mHostAddressInfo->ai_addrlen);
+ if (hr == SOCKET_ERROR) {
+ glv_LogError("Host: Failed binding socket err=%d\n", GLV_WSAGetLastError());
+ freeaddrinfo(pStream->mHostAddressInfo);
+ pStream->mHostAddressInfo = NULL;
+ closesocket(listenSocket);
+ return FALSE;
+ }
+
+ // Done with this.
+ freeaddrinfo(pStream->mHostAddressInfo);
+ pStream->mHostAddressInfo = NULL;
+
+ hr = listen(listenSocket, 1);
+ if (hr == SOCKET_ERROR) {
+ glv_LogError("Host: Failed listening on socket err=%d\n");
+ closesocket(listenSocket);
+ return FALSE;
+ }
+
+ // Fo reals.
+ pStream->mSocket = accept(listenSocket, NULL, NULL);
+ closesocket(listenSocket);
+
+ if (pStream->mSocket == INVALID_SOCKET) {
+ glv_LogError("Host: Failed accepting socket connection\n");
+ return FALSE;
+ }
+
+ if (glv_MessageStream_Handshake(pStream))
+ {
+ // TODO: The SendBuffer can cause big delays in sending messages back to the client.
+ // We haven't verified if this improves performance in real applications,
+ // so disable it for now.
+ //pStream->mSendBuffer = glv_SimpleBuffer_create(kSendBufferSize);
+ pStream->mSendBuffer = NULL;
+ }
+ else
+ {
+ glv_LogError("glv_MessageStream_SetupHostSocket failed handshake\n");
+ }
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_SetupClientSocket(MessageStream* pStream)
+{
+ int hr = 0;
+ unsigned int attempt = 0;
+ BOOL bConnected = FALSE;
+ struct addrinfo hostAddrInfo = { 0 },
+ *currentAttempt = NULL;
+
+ hostAddrInfo.ai_family = AF_UNSPEC;
+ hostAddrInfo.ai_socktype = SOCK_STREAM;
+ hostAddrInfo.ai_protocol = IPPROTO_TCP;
+
+ hr = getaddrinfo(pStream->mAddress, pStream->mPort, &hostAddrInfo, &pStream->mHostAddressInfo);
+ if (hr != 0) {
+ glv_LogError("Client: Failed getaddrinfo\n");
+ return FALSE;
+ }
+
+ // make several attempts to connect before bailing out
+ for (attempt = 0; attempt < 10 && !bConnected; attempt++)
+ {
+ for (currentAttempt = pStream->mHostAddressInfo; currentAttempt != NULL; currentAttempt = currentAttempt->ai_next)
+ {
+ pStream->mSocket = socket(currentAttempt->ai_family, currentAttempt->ai_socktype, currentAttempt->ai_protocol);
+
+ hr = connect(pStream->mSocket, currentAttempt->ai_addr, (int)currentAttempt->ai_addrlen);
+ if (hr == SOCKET_ERROR)
+ {
+ glv_LogVerbose("Client: Failed connect. Possibly non-fatal.\n");
+ closesocket(pStream->mSocket);
+ pStream->mSocket = INVALID_SOCKET;
+ continue;
+ }
+
+ bConnected = TRUE;
+ break;
+ }
+
+ if (!bConnected)
+ {
+ Sleep(1);
+ glv_LogVerbose("Client: Connect attempt %u on port %s failed, trying again.\n", attempt, pStream->mPort);
+ }
+ else
+ {
+ glv_LogVerbose("Client: Connected to port %s successfully\n", pStream->mPort);
+ }
+ }
+
+ freeaddrinfo(pStream->mHostAddressInfo);
+ pStream->mHostAddressInfo = NULL;
+
+ if (pStream->mSocket == INVALID_SOCKET) {
+ glv_LogError("Client: Couldn't find any connections.\n");
+ return FALSE;
+ }
+
+ if (!glv_MessageStream_Handshake(pStream))
+ {
+ glv_LogError("Client: Failed handshake with host.\n");
+ return FALSE;
+ }
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_Handshake(MessageStream* pStream)
+{
+ BOOL result = TRUE;
+ FileLike* fileLike = glv_FileLike_create_msg(pStream);
+ Checkpoint* syn = glv_Checkpoint_create("It's a trap!");
+ Checkpoint* ack = glv_Checkpoint_create(" - Admiral Ackbar");
+
+ if (pStream->mHost) {
+ glv_Checkpoint_write(syn, fileLike);
+ result = glv_Checkpoint_read(ack, fileLike);
+ } else {
+ if (glv_Checkpoint_read(syn, fileLike))
+ {
+ glv_Checkpoint_write(ack, fileLike);
+ }
+ else
+ {
+ result = FALSE;
+ }
+ }
+
+ // Turn on non-blocking modes for sockets now.
+ if (result)
+ {
+#if defined(WIN32)
+ u_long asyncMode = 1;
+ ioctlsocket(pStream->mSocket, FIONBIO, &asyncMode);
+#else
+ fcntl(pStream->mSocket, F_SETFL, O_NONBLOCK);
+#endif
+ }
+
+ GLV_DELETE(syn);
+ GLV_DELETE(ack);
+ GLV_DELETE(fileLike);
+
+ return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+void glv_MessageStream_FlushSendBuffer(MessageStream* pStream, BOOL _optional)
+{
+ size_t bufferedByteSize = 0;
+ const void* bufferBytes = glv_SimpleBuffer_GetBytes(pStream->mSendBuffer, &bufferedByteSize);
+ if (bufferedByteSize > 0) {
+ // TODO use return value from ReallySend
+ glv_MessageStream_ReallySend(pStream, bufferBytes, bufferedByteSize, _optional);
+ glv_SimpleBuffer_EmptyBuffer(pStream->mSendBuffer);
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_BufferedSend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional)
+{
+ BOOL result = TRUE;
+ if (pStream->mSendBuffer == NULL) {
+ result = glv_MessageStream_ReallySend(pStream, _bytes, _size, _optional);
+ }
+ else
+ {
+ if (!glv_SimpleBuffer_WouldOverflow(pStream->mSendBuffer, _size)) {
+ result = glv_SimpleBuffer_AddBytes(pStream->mSendBuffer, _bytes, _size);
+ } else {
+ // Time to flush the cache.
+ glv_MessageStream_FlushSendBuffer(pStream, FALSE);
+
+ // Check to see if the packet is larger than the send buffer
+ if (glv_SimpleBuffer_WouldOverflow(pStream->mSendBuffer, _size)) {
+ result = glv_MessageStream_ReallySend(pStream, _bytes, _size, _optional);
+ } else {
+ result = glv_SimpleBuffer_AddBytes(pStream->mSendBuffer, _bytes, _size);
+ }
+ }
+ }
+ return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_Send(MessageStream* pStream, const void* _bytes, size_t _len)
+{
+ return glv_MessageStream_BufferedSend(pStream, _bytes, _len, FALSE);
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_ReallySend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional)
+{
+ size_t bytesSent = 0;
+ assert(_size > 0);
+
+ do {
+ int sentThisTime = send(pStream->mSocket, (const char*)_bytes + bytesSent, (int)_size - (int)bytesSent, 0);
+ if (sentThisTime == SOCKET_ERROR) {
+ int socketError = GLV_WSAGetLastError();
+ if (socketError == WSAEWOULDBLOCK) {
+ // Try again. Don't sleep, because that nukes performance from orbit.
+ continue;
+ }
+
+ if (!_optional) {
+ return FALSE;
+ }
+ }
+ if (sentThisTime == 0) {
+ if (!_optional) {
+ return FALSE;
+ }
+ break;
+ }
+
+ bytesSent += sentThisTime;
+
+ } while (bytesSent < _size);
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_Recv(MessageStream* pStream, void* _out, size_t _len)
+{
+ unsigned int totalDataRead = 0;
+ do {
+ int dataRead = recv(pStream->mSocket, ((char*)_out) + totalDataRead, (int)_len - totalDataRead, 0);
+ if (dataRead == SOCKET_ERROR) {
+ pStream->mErrorNum = GLV_WSAGetLastError();
+ if (pStream->mErrorNum == WSAEWOULDBLOCK || pStream->mErrorNum == EAGAIN) {
+ if (totalDataRead == 0) {
+ return FALSE;
+ } else {
+ // I don't do partial reads--once I start receiving I wait for everything.
+ glv_LogDebug("Sleep on partial socket recv (%u bytes / %u), error num %d\n", totalDataRead, _len, pStream->mErrorNum);
+ Sleep(1);
+ }
+ // I've split these into two blocks because one of them is expected and the other isn't.
+ } else if (pStream->mErrorNum == WSAECONNRESET) {
+ // The remote client disconnected, probably not an issue.
+ return FALSE;
+ } else {
+ // Some other wonky network error--place a breakpoint here.
+ glv_LogError("Unexpected error (%d) while receiving message stream\n", pStream->mErrorNum);
+ return FALSE;
+ }
+ } else {
+ totalDataRead += dataRead;
+ }
+ } while (totalDataRead < _len);
+
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_MessageStream_BlockingRecv(MessageStream* pStream, void* _outBuffer, size_t _len)
+{
+ while (!glv_MessageStream_Recv(pStream, _outBuffer, _len)) {
+ Sleep(1);
+ }
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+SimpleBuffer* glv_SimpleBuffer_create(size_t _bufferSize)
+{
+ SimpleBuffer* pBuffer = GLV_NEW(SimpleBuffer);
+ pBuffer->mBuffer = (unsigned char*)glv_malloc(_bufferSize);
+ if (pBuffer->mBuffer == NULL)
+ {
+ GLV_DELETE(pBuffer);
+ return NULL;
+ }
+
+ pBuffer->mEnd = 0;
+ pBuffer->mSize = _bufferSize;
+
+ return pBuffer;
+}
+
+void glv_SimpleBuffer_destroy(SimpleBuffer** ppBuffer)
+{
+ glv_free((*ppBuffer)->mBuffer);
+ GLV_DELETE(*ppBuffer);
+}
+
+BOOL glv_SimpleBuffer_AddBytes(SimpleBuffer* pBuffer, const void* _bytes, size_t _size)
+{
+ if (glv_SimpleBuffer_WouldOverflow(pBuffer, _size))
+ {
+ return FALSE;
+ }
+
+ memcpy((unsigned char*)pBuffer->mBuffer + pBuffer->mEnd, _bytes, _size);
+ pBuffer->mEnd += _size;
+
+ return TRUE;
+}
+
+void glv_SimpleBuffer_EmptyBuffer(SimpleBuffer* pBuffer)
+{
+ pBuffer->mEnd = 0;
+}
+
+BOOL glv_SimpleBuffer_WouldOverflow(SimpleBuffer* pBuffer, size_t _requestedSize)
+{
+ return pBuffer->mEnd + _requestedSize > pBuffer->mSize;
+}
+
+const void* glv_SimpleBuffer_GetBytes(SimpleBuffer* pBuffer, size_t* _outByteCount)
+{
+ (*_outByteCount) = pBuffer->mEnd;
+ return pBuffer->mBuffer;
+}
+
+//// ------------------------------------------------------------------------------------------------
+//void RemoteCommand::Read(FileLike* _fileLike)
+//{
+// unsigned int myCommand = 0;
+// _fileLike->Read(&myCommand);
+// mRemoteCommandType = (EnumRemoteCommand)myCommand;
+//}
+//
+//// ------------------------------------------------------------------------------------------------
+//void RemoteCommand::Write(FileLike* _fileLike) const
+//{
+// _fileLike->Write((unsigned int)mRemoteCommandType);
+//}
diff --git a/tools/glave/src/glvcommon/glv_interconnect.h b/tools/glave/src/glvcommon/glv_interconnect.h
new file mode 100644
index 0000000..d7677c4
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_interconnect.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+
+#pragma once
+
+#include <errno.h>
+#include "glv_common.h"
+
+#if defined(PLATFORM_POSIX)
+ #include <arpa/inet.h>
+ #include <netdb.h>
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+ #include <sys/socket.h>
+ #define SOCKET int
+ #define INVALID_SOCKET 0
+ #define SOCKET_ERROR -1
+ #define closesocket close
+ #define GLV_WSAGetLastError() errno
+ #define WSAEWOULDBLOCK EWOULDBLOCK
+ #define WSAEAGAIN EAGAIN
+ #define WSAECONNRESET ECONNRESET
+#elif defined(WIN32)
+ #include <WinSock2.h>
+ #include <WS2tcpip.h>
+ #pragma comment (lib, "Ws2_32.lib")
+ #define GLV_WSAGetLastError() WSAGetLastError()
+#endif
+
+static const unsigned int GLV_BASE_PORT = 34199;
+struct SSerializeDataPacket;
+
+struct SimpleBuffer;
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+typedef struct MessageStream
+{
+ SOCKET mSocket;
+ struct addrinfo* mHostAddressInfo;
+ size_t mNextPacketId;
+ struct SimpleBuffer* mSendBuffer;
+
+ // Used if someone asks for a receive of a small string.
+ char mSmallBuffer[64];
+
+ char mAddress[64];
+
+ char mPort[8];
+
+ BOOL mHost;
+ int mErrorNum;
+} MessageStream;
+
+MessageStream* glv_MessageStream_create_port_string(BOOL _isHost, const char* _address, const char* _port);
+MessageStream* glv_MessageStream_create(BOOL _isHost, const char* _address, unsigned int _port);
+void glv_MessageStream_destroy(MessageStream** ppStream);
+BOOL glv_MessageStream_BufferedSend(MessageStream* pStream, const void* _bytes, size_t _size, BOOL _optional);
+BOOL glv_MessageStream_Send(MessageStream* pStream, const void* _bytes, size_t _len);
+
+BOOL glv_MessageStream_Recv(MessageStream* pStream, void* _out, size_t _len);
+BOOL glv_MessageStream_BlockingRecv(MessageStream* pStream, void* _outBuffer, size_t _len);
+
+extern MessageStream* gMessageStream;
+
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------------------------
+typedef struct SimpleBuffer
+{
+ void* mBuffer;
+ size_t mEnd;
+ size_t mSize;
+} SimpleBuffer;
+
+SimpleBuffer* glv_SimpleBuffer_create(size_t _bufferSize);
+void glv_SimpleBuffer_destroy(SimpleBuffer** ppBuffer);
+BOOL glv_SimpleBuffer_AddBytes(SimpleBuffer* pBuffer, const void* _bytes, size_t _size);
+void glv_SimpleBuffer_EmptyBuffer(SimpleBuffer* pBuffer);
+BOOL glv_SimpleBuffer_WouldOverflow(SimpleBuffer* pBuffer, size_t _requestedSize);
+const void* glv_SimpleBuffer_GetBytes(SimpleBuffer* pBuffer, size_t* _outByteCount);
diff --git a/tools/glave/src/glvcommon/glv_memory.h b/tools/glave/src/glvcommon/glv_memory.h
new file mode 100644
index 0000000..6cba374
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_memory.h
@@ -0,0 +1,162 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define GLV_NEW(type) (type*)glv_malloc(sizeof(type))
+#define GLV_NEW_ARRAY(type, count) (type*)glv_malloc(sizeof(type)*count)
+#define GLV_DELETE(ptr) glv_free(ptr);
+#define GLV_REALLOC(ptr, size) glv_realloc(ptr, size);
+
+static void* glv_malloc(size_t size)
+{
+ void* pMem;
+ if (size == 0)
+ return NULL;
+
+ pMem = malloc(size);
+ if (pMem != NULL)
+ {
+ memset(pMem, 0, size);
+ }
+
+ return pMem;
+}
+
+static void glv_free(void* ptr)
+{
+ free(ptr);
+ ptr = NULL;
+}
+
+static void * glv_realloc(void *ptr,size_t size)
+{
+ void *pMem;
+ if (size == 0)
+ return NULL;
+
+ pMem = realloc(ptr, size);
+ if (pMem != NULL)
+ {
+ memset(pMem, 0, size);
+ }
+ return pMem;
+}
+
+static char* glv_allocate_and_copy(const char* _src)
+{
+ if (_src == NULL)
+ {
+ return NULL;
+ }
+ else
+ {
+ size_t bufferSize = 1 + strlen(_src);
+
+ char* retVal = GLV_NEW_ARRAY(char, bufferSize);
+#ifdef WIN32
+ strcpy_s(retVal, bufferSize, _src);
+#else // linux
+ strncpy(retVal, _src, bufferSize);
+#endif
+
+ return retVal;
+ }
+}
+
+static char* glv_allocate_and_copy_n(const char* _src, int _count)
+{
+ size_t bufferSize = 1 + _count;
+
+ char* retVal = GLV_NEW_ARRAY(char, bufferSize);
+
+#ifdef WIN32
+ strncpy_s(retVal, bufferSize, _src, _count);
+#else // linux
+ strncpy(retVal, _src, bufferSize);
+#endif
+
+ return retVal;
+}
+
+static char* glv_copy_and_append(const char* pBaseString, const char* pSeparator, const char* pAppendString)
+{
+ size_t baseSize = (pBaseString != NULL) ? strlen(pBaseString) : 0;
+ size_t separatorSize = (pSeparator != NULL) ? strlen(pSeparator) : 0;
+ size_t appendSize = (pAppendString != NULL) ? strlen(pAppendString) : 0;
+ size_t bufferSize = baseSize + separatorSize + appendSize + 1;
+ char* retVal = GLV_NEW_ARRAY(char, bufferSize);
+ if (retVal != NULL)
+ {
+#ifdef WIN32
+ strncpy_s(retVal, bufferSize, pBaseString, baseSize);
+ strncpy_s(&retVal[baseSize], bufferSize-baseSize, pSeparator, separatorSize);
+ strncpy_s(&retVal[baseSize+separatorSize], bufferSize-baseSize-separatorSize, pAppendString, appendSize);
+#else // linux
+ strncpy(retVal, pBaseString, baseSize);
+ strncpy(&retVal[baseSize], pSeparator, separatorSize);
+ strncpy(&retVal[baseSize+separatorSize], pAppendString, appendSize);
+#endif
+ }
+ return retVal;
+}
+
+static char* glv_copy_and_append_args(const char* pBaseString, const char* pSeparator, const char* pAppendFormat, va_list args)
+{
+ size_t baseSize = (pBaseString != NULL) ? strlen(pBaseString) : 0;
+ size_t separatorSize = (pSeparator != NULL) ? strlen(pSeparator) : 0;
+ size_t appendSize = 0;
+ size_t bufferSize = 0;
+ char* retVal = NULL;
+
+#if defined(WIN32)
+ appendSize = _vscprintf(pAppendFormat, args);
+#elif defined(PLATFORM_LINUX)
+ va_list argcopy;
+ va_copy(argcopy, args);
+ appendSize = vsnprintf(NULL, 0, pAppendFormat, argcopy);
+ va_end(argcopy);
+#endif
+
+ bufferSize = baseSize + separatorSize + appendSize + 1;
+ retVal = GLV_NEW_ARRAY(char, bufferSize);
+ if (retVal != NULL)
+ {
+#ifdef WIN32
+ strncpy_s(retVal, bufferSize, pBaseString, baseSize);
+ strncpy_s(&retVal[baseSize], bufferSize-baseSize, pSeparator, separatorSize);
+ _vsnprintf_s(&retVal[baseSize+separatorSize], bufferSize-baseSize-separatorSize, appendSize, pAppendFormat, args);
+#else // linux
+ strncpy(retVal, pBaseString, baseSize);
+ strncpy(&retVal[baseSize], pSeparator, separatorSize);
+ vsnprintf(&retVal[baseSize+separatorSize], appendSize, pAppendFormat, args);
+#endif
+ }
+ return retVal;
+}
+
diff --git a/tools/glave/src/glvcommon/glv_mhook.h b/tools/glave/src/glvcommon/glv_mhook.h
new file mode 100644
index 0000000..e97f6b2
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_mhook.h
@@ -0,0 +1,35 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "mhook/mhook-lib/mhook.h"
+#include "glv_tracelog.h"
+#include <stdio.h>
+
+#define GLV_MHOOK_SETHOOK(entrypoint) Mhook_SetHook((PVOID*)&real_##entrypoint, hooked_##entrypoint); \
+ if (hookSuccess == FALSE) { glv_LogError("Failed to hook " #entrypoint "\n"); }
+
+#define GLV_MHOOK_UNHOOK(entrypoint) Mhook_Unhook((PVOID*)&real_##entrypoint); \
+ if (unhookSuccess == FALSE) { printf("Failed to unhook " #entrypoint "\n"); }
diff --git a/tools/glave/src/glvcommon/glv_platform.c b/tools/glave/src/glvcommon/glv_platform.c
new file mode 100644
index 0000000..ff01d86
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_platform.c
@@ -0,0 +1,368 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glv_platform.h"
+
+#if defined(PLATFORM_LINUX)
+#include "glv_common.h"
+#include <pthread.h>
+#endif
+
+glv_process_id glv_get_pid()
+{
+#if defined(PLATFORM_LINUX)
+ return getpid();
+#elif defined(WIN32)
+ return GetCurrentProcessId();
+#endif
+}
+
+char* glv_platform_get_current_executable_directory()
+{
+ char* exePath = (char*)glv_malloc(_MAX_PATH);
+#if defined(WIN32)
+ DWORD s = GetModuleFileName(NULL, exePath, MAX_PATH);
+#elif defined(PLATFORM_LINUX)
+ ssize_t s = readlink("/proc/self/exe", exePath, _MAX_PATH);
+ if (s >= 0)
+ {
+ exePath[s] = '\0';
+ }
+ else
+ {
+ exePath[0] = '\0';
+ }
+#endif
+
+ while (s > 0)
+ {
+ if (exePath[s] == '/' || exePath[s] == '\\')
+ {
+ // NULL this location and break so that the shortened string can be returned.
+ exePath[s] = '\0';
+ break;
+ }
+
+ --s;
+ }
+
+ if (s <= 0)
+ {
+ assert(!"Unexpected path returned in glv_platform_get_current_executable_directory");
+ glv_free(exePath);
+ exePath = NULL;
+ }
+
+ return exePath;
+}
+
+BOOL glv_is_loaded_into_glvtrace()
+{
+ char exePath[_MAX_PATH];
+
+#if defined(WIN32)
+ char* substr = ((sizeof(void*) == 4)? "glvtrace32.exe" : "glvtrace64.exe");
+ GetModuleFileName(NULL, exePath, MAX_PATH);
+#elif defined(PLATFORM_LINUX)
+ char* substr = ((sizeof(void*) == 4)? "glvtrace32" : "glvtrace64");
+ ssize_t s = readlink("/proc/self/exe", exePath, _MAX_PATH);
+ if (s >= 0)
+ {
+ exePath[s] = '\0';
+ }
+ else
+ {
+ exePath[0] = '\0';
+ }
+#endif
+ return (strstr(exePath, substr) != NULL);
+}
+
+BOOL glv_platform_get_next_lib_sym(void * *ppFunc, const char * name)
+{
+#if defined(PLATFORM_LINUX)
+ if ((*ppFunc = dlsym(RTLD_NEXT, name)) == NULL) {
+ glv_LogError("dlsym: failed to find symbol %s %s\n", name, dlerror());
+ return FALSE;
+ }
+#elif defined(WIN32)
+ glv_LogError("unimplemented");
+ assert(0);
+ return FALSE;
+#endif
+ return TRUE;
+}
+
+glv_thread_id glv_platform_get_thread_id()
+{
+#if defined(PLATFORM_LINUX)
+ //return (glv_thread_id)syscall(SYS_gettid);
+ return pthread_self();
+#elif defined(WIN32)
+ return GetCurrentThreadId();
+#endif
+}
+
+size_t glv_platform_rand_s(uint32_t* out_array, size_t out_array_length)
+{
+#if defined(PLATFORM_LINUX)
+ static __thread unsigned int s_seed = 0;
+ size_t i = 0;
+
+ if (s_seed == 0)
+ {
+ // Try to seed rand_r() with /dev/urandom.
+ size_t nbytes = 0;
+ int fd = open("/dev/urandom", O_RDONLY);
+ if (fd != -1)
+ {
+ nbytes = read(fd, &s_seed, sizeof(s_seed));
+ close(fd);
+ }
+
+ // If that didn't work, fallback to time and thread id.
+ if (nbytes != sizeof(s_seed))
+ {
+ struct timeval time;
+ gettimeofday(&time, NULL);
+ s_seed = glv_platform_get_thread_id() ^ ((time.tv_sec * 1000) + (time.tv_usec / 1000));
+ }
+ }
+
+ for (i = 0; i < out_array_length; ++i)
+ {
+ out_array[i] = rand_r(&s_seed);
+ }
+
+ return out_array_length;
+#elif defined(WIN32)
+ //GLV_ASSUME(sizeof(uint32_t) == sizeof(unsigned int));
+
+ size_t ret_values = 0;
+ for (ret_values = 0; ret_values < out_array_length; ++ret_values)
+ {
+ if (FAILED(rand_s(&out_array[ret_values])))
+ return ret_values;
+ }
+
+ return ret_values;
+#endif
+}
+
+void * glv_platform_open_library(const char* libPath)
+{
+#if defined(WIN32)
+ return LoadLibrary(libPath);
+#elif defined(PLATFORM_LINUX)
+ return dlopen(libPath, RTLD_LAZY);
+#endif
+}
+
+void * glv_platform_get_library_entrypoint(void * libHandle, const char *name)
+{
+
+#ifdef WIN32
+ FARPROC proc = GetProcAddress((HMODULE)libHandle, name);
+ if (!proc)
+ glv_LogError("Failed to find symbol %s in library handle %p\n", name, libHandle);
+#else
+ void * proc = dlsym(libHandle, name);
+ if (!proc)
+ glv_LogError("Failed to find symbol %s in library handle %p, err %s\n", name, libHandle, dlerror());
+#endif
+ assert(libHandle);
+ return proc;
+}
+
+void glv_platform_close_library(void* pLibrary)
+{
+#if defined(WIN32)
+ FreeLibrary((HMODULE)pLibrary);
+#elif defined(PLATFORM_LINUX)
+ dlclose(pLibrary);
+#endif
+}
+
+void glv_platform_full_path(const char* partPath, unsigned long bytes, char* buffer)
+{
+ assert(buffer != NULL);
+#if defined(WIN32)
+ GetFullPathName(partPath, bytes, buffer, NULL);
+#elif defined(PLATFORM_LINUX)
+ realpath(partPath, buffer);
+#endif
+}
+
+char* glv_platform_extract_path(char* _path)
+{
+ // These functions actually work on const strings, but the C decl version exposed by the macro
+ // takes non-const TCHAR*.
+ char* pDir;
+ size_t newLen;
+ char* pathSepBack = strrchr(_path, '\\');
+ char* pathSepFor = strrchr(_path, '/');
+ char* lastPathSep = pathSepBack > pathSepFor ? pathSepBack : pathSepFor;
+
+ if (lastPathSep == NULL)
+ {
+ return ".\\";
+ }
+
+ pDir = GLV_NEW_ARRAY(char, strlen(_path) + 1);
+ newLen = strlen(_path) - strlen(lastPathSep);
+ strncpy(pDir, _path, newLen);
+ pDir[newLen + 1] = '\0';
+ return pDir;
+}
+
+glv_thread glv_platform_create_thread(GLV_THREAD_ROUTINE_RETURN_TYPE(*start_routine)(LPVOID), void* args)
+{
+#if defined(PLATFORM_LINUX)
+ glv_thread thread = 0;
+ if(pthread_create(&thread, NULL, (void *(*) (void*)) start_routine, args) != 0)
+ {
+ glv_LogError("Failed to create thread");
+ }
+ return thread;
+#elif defined(WIN32)
+ return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)start_routine, args, 0, NULL);
+#endif
+}
+
+void glv_platform_resume_thread(glv_thread* pThread)
+{
+ assert(pThread != NULL);
+#if defined(PLATFORM_LINUX)
+ assert(!"Add code to resume threads on Linux");
+#elif defined(WIN32)
+ assert(*pThread != NULL);
+ ResumeThread(*pThread);
+#endif
+}
+
+void glv_platform_sync_wait_for_thread(glv_thread* pThread)
+{
+ assert(pThread != NULL);
+#if defined(PLATFORM_LINUX)
+ if (pthread_join(*pThread, NULL) != 0)
+#else
+ if (WaitForSingleObject(*pThread, INFINITE) != WAIT_OBJECT_0)
+#endif
+ {
+ glv_LogError("Error occurred while waiting for thread to end.\n");
+ }
+}
+
+void glv_platform_delete_thread(glv_thread* pThread)
+{
+ assert(pThread != NULL);
+#if defined(PLATFORM_LINUX)
+ // Don't have to do anything!
+#elif defined(WIN32)
+ CloseHandle(*pThread);
+ *pThread = NULL;
+#endif
+}
+
+void glv_create_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+{
+#if defined(WIN32)
+ InitializeCriticalSection(pCriticalSection);
+#elif defined(PLATFORM_LINUX)
+ pthread_mutex_init(pCriticalSection, NULL);
+#endif
+}
+
+void glv_enter_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+{
+#if defined(WIN32)
+ EnterCriticalSection(pCriticalSection);
+#elif defined(PLATFORM_LINUX)
+ pthread_mutex_lock(pCriticalSection);
+#endif
+}
+
+void glv_leave_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+{
+#if defined(WIN32)
+ LeaveCriticalSection(pCriticalSection);
+#elif defined(PLATFORM_LINUX)
+ pthread_mutex_unlock(pCriticalSection);
+#endif
+}
+
+void glv_delete_critical_section(GLV_CRITICAL_SECTION* pCriticalSection)
+{
+#if defined(WIN32)
+ DeleteCriticalSection(pCriticalSection);
+#elif defined(PLATFORM_LINUX)
+ pthread_mutex_destroy(pCriticalSection);
+#endif
+}
+
+BOOL glv_platform_remote_load_library(glv_process_handle pProcessHandle, const char* dllPath, glv_thread* pTracingThread, char ** ldPreload)
+{
+#if defined(WIN32)
+ SIZE_T bytesWritten = 0;
+ void* targetProcessMem = NULL;
+ glv_thread thread = NULL;
+ size_t byteCount = sizeof(char) * (strlen(dllPath) + 1);
+ targetProcessMem = VirtualAllocEx(pProcessHandle, 0, byteCount, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+ if (!targetProcessMem)
+ {
+ glv_LogError("Failed to inject ourselves into target process--couldn't allocate process memory.\n");
+ return FALSE;
+ }
+
+ if (!WriteProcessMemory(pProcessHandle, targetProcessMem, dllPath, byteCount, &bytesWritten))
+ {
+ glv_LogError("Failed to inject ourselves into target process--couldn't write inception DLL name into process.\n");
+ return FALSE;
+ }
+
+ thread = CreateRemoteThread(pProcessHandle, NULL, 0, (LPTHREAD_START_ROUTINE)LoadLibrary, targetProcessMem, 0, NULL);
+ if (thread == NULL)
+ {
+ glv_LogError("Failed to inject ourselves into target process--couldn't spawn thread.\n");
+ return FALSE;
+ }
+ assert(pTracingThread != NULL);
+ *pTracingThread = thread;
+
+#elif defined(PLATFORM_LINUX)
+ char *tmp;
+ if (*ldPreload == NULL)
+ {
+ tmp = glv_copy_and_append("LD_PRELOAD", "=", dllPath);
+ }
+ else
+ {
+ tmp = glv_copy_and_append(*ldPreload, " ", dllPath);
+ GLV_DELETE((void*)*ldPreload);
+ }
+ *ldPreload = tmp;
+#endif
+
+ return TRUE;
+}
diff --git a/tools/glave/src/glvcommon/glv_platform.h b/tools/glave/src/glvcommon/glv_platform.h
new file mode 100644
index 0000000..ca03718
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_platform.h
@@ -0,0 +1,116 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+
+#if defined(PLATFORM_LINUX)
+#define _GNU_SOURCE 1
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <spawn.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/prctl.h>
+#include <dlfcn.h>
+#include "wintypes.h"
+#define APIENTRY
+#define Sleep(n) usleep(n * 1000)
+#define GLV_WINAPI
+typedef pthread_t glv_thread;
+typedef pid_t glv_process_handle;
+typedef pid_t glv_thread_id;
+typedef pid_t glv_process_id;
+typedef unsigned int GLV_THREAD_ROUTINE_RETURN_TYPE;
+typedef pthread_mutex_t GLV_CRITICAL_SECTION;
+#define GLV_NULL_THREAD 0
+#define _MAX_PATH PATH_MAX
+
+#elif defined(WIN32)
+#define _CRT_RAND_S
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <tchar.h>
+#define GLV_WINAPI WINAPI
+typedef HANDLE glv_thread;
+typedef HANDLE glv_process_handle;
+typedef DWORD glv_thread_id;
+typedef DWORD glv_process_id;
+typedef DWORD GLV_THREAD_ROUTINE_RETURN_TYPE;
+typedef CRITICAL_SECTION GLV_CRITICAL_SECTION;
+#define GLV_NULL_THREAD NULL
+#endif
+
+#if defined(WIN32)
+#include "glv_common.h"
+#endif
+
+// return the process ID of current process
+glv_process_id glv_get_pid();
+
+// Get the path of the currently running executable.
+// The string returned must be freed by the caller.
+char* glv_platform_get_current_executable_directory();
+
+// Determine if the current process is glvtrace[32|64]
+BOOL glv_is_loaded_into_glvtrace();
+
+// Get the thread id for this thread.
+glv_thread_id glv_platform_get_thread_id();
+
+// Provides out_array_length uint32s of random data from a secure service
+size_t glv_platform_rand_s(uint32_t* out_array, size_t byteCount);
+
+// Alternatives to loading libraries, getting proc addresses, etc
+void * glv_platform_open_library(const char* libPath);
+void * glv_platform_get_library_entrypoint(void * libHandle, const char *name);
+void glv_platform_close_library(void* plibrary);
+BOOL glv_platform_get_next_lib_sym(void * *ppFunc, const char * name);
+
+// Returns the partial path appended to the current directory to provide a full path.
+// Note the resulting string may not point to an existing file.
+void glv_platform_full_path(const char* partPath, unsigned long bytes, char* buffer);
+
+// returns a newly allocated string which contains just the directory structure of the supplied file path.
+char* glv_platform_extract_path(char* _path);
+
+glv_thread glv_platform_create_thread(GLV_THREAD_ROUTINE_RETURN_TYPE(*start_routine)(LPVOID), void* args);
+void glv_platform_resume_thread(glv_thread* pThread);
+void glv_platform_sync_wait_for_thread(glv_thread* pThread);
+void glv_platform_delete_thread(glv_thread* pThread);
+
+void glv_create_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
+void glv_enter_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
+void glv_leave_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
+void glv_delete_critical_section(GLV_CRITICAL_SECTION* pCriticalSection);
+
+#if defined(PLATFORM_LINUX)
+#define GLV_LIBRARY_NAME(projname) (sizeof(void*) == 4)? "lib"#projname"32.so" : "lib"#projname"64.so"
+#endif
+#if defined(WIN32)
+#define GLV_LIBRARY_NAME(projname) (sizeof(void*) == 4)? #projname"32.dll" : #projname"64.dll"
+#endif
+
+BOOL glv_platform_remote_load_library(glv_process_handle pProcessHandle, const char* dllPath, glv_thread* pTracingThread, char **ldPreload);
diff --git a/tools/glave/src/glvcommon/glv_process.c b/tools/glave/src/glvcommon/glv_process.c
new file mode 100644
index 0000000..9d4e221
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_process.c
@@ -0,0 +1,175 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glv_process.h"
+
+
+BOOL glv_process_spawn(glv_process_info* pInfo)
+{
+ assert(pInfo != NULL);
+
+#if defined(WIN32)
+ {
+ unsigned long processCreateFlags = CREATE_DEFAULT_ERROR_MODE | CREATE_SUSPENDED;
+ char fullExePath[_MAX_PATH];
+ PROCESS_INFORMATION processInformation;
+ STARTUPINFO si = { 0 };
+ si.cb = sizeof(si);
+
+ memset(&processInformation, 0, sizeof(PROCESS_INFORMATION));
+ memset(fullExePath, 0, sizeof(char)*_MAX_PATH);
+ fullExePath[0] = 0;
+
+ SetLastError(0);
+ SearchPath(NULL, pInfo->exeName, ".exe", ARRAYSIZE(fullExePath), fullExePath, NULL);
+
+ if (!CreateProcess(fullExePath, pInfo->processArgs, NULL, NULL, TRUE,
+ processCreateFlags, NULL, pInfo->workingDirectory,
+ &si, &processInformation))
+ {
+ glv_LogError("Failed to inject ourselves into target process--couldn't spawn '%s'.\n", fullExePath);
+ return FALSE;
+ }
+
+ pInfo->hProcess = processInformation.hProcess;
+ pInfo->hThread = processInformation.hThread;
+ pInfo->processId = processInformation.dwProcessId;
+ pInfo->hThread = processInformation.hThread;
+ }
+#elif defined(PLATFORM_LINUX)
+ pInfo->processId = fork();
+ if (pInfo->processId == -1)
+ {
+ glv_LogError("Failed to spawn process.\n");
+ return FALSE;
+ }
+ else if (pInfo->processId == 0)
+ {
+ char *envp[5];
+ envp[0] = pInfo->processLDPreload;
+ envp[4] = (char *) (NULL);
+ static char default_disp[] = "DISPLAY=:0";
+ char * libxgl_drivers_path = (char *) (NULL);
+ char * env_display = (char *) NULL;
+ char * ld_library_path = (char *) NULL;
+
+ // inside new process
+ // change process name so the the tracer DLLs will behave as expected when loaded.
+ // NOTE: Must be 15 characters or less.
+ const char * tmpProcName = "glvChildProcess";
+ prctl(PR_SET_NAME, (unsigned long)tmpProcName, 0, 0, 0);
+
+ // change working directory
+ if (chdir(pInfo->workingDirectory) == -1)
+ {
+ glv_LogError("Failed to set working directory.\n");
+ }
+
+ env_display = getenv("DISPLAY");
+ if (env_display != NULL)
+ {
+ char *disp = malloc(strlen(env_display) + strlen("DISPLAY=") + 1);
+ if (disp == NULL)
+ glv_LogError("Failed to malloc for env_display in glv_process_spawn().\n");
+ snprintf(disp, strlen(env_display) + strlen("DISPLAY=") + 1, "DISPLAY=%s", env_display);
+
+ envp[1] = disp;
+ } else
+ {
+ envp[1] = default_disp;
+ }
+
+ // TODO this needs to be generalized for other drivers
+ libxgl_drivers_path = getenv("LIBXGL_DRIVERS_PATH");
+ if (libxgl_drivers_path == NULL)
+ {
+ glv_LogWarn("LIBXGL_DRIVERS_PATH env var was not set. We recommend that you set it.\n");
+ envp[2] = NULL;
+ }
+ else
+ {
+ char *dPath = malloc(strlen(libxgl_drivers_path) + strlen("LIBXGL_DRIVERS_PATH=") + 1);
+ if (dPath == NULL)
+ glv_LogError("Failed to malloc in glv_process_spawn().\n");
+ snprintf(dPath, strlen(libxgl_drivers_path) + strlen("LIBXGL_DRIVERS_PATH=") + 1, "LIBXGL_DRIVERS_PATH=%s", libxgl_drivers_path);
+ envp[2] = dPath;
+ }
+
+ ld_library_path = getenv("LD_LIBRARY_PATH");
+ if (ld_library_path != NULL)
+ {
+ char *ld_lib = malloc(strlen(ld_library_path) + strlen("LD_LIBRARY_PATH=") + 1);
+ if (ld_lib == NULL)
+ glv_LogError("Failed to malloc for LD_LIBRARY_PATH in glv_process_spawn().\n");
+ snprintf(ld_lib, strlen(ld_library_path) + strlen("LD_LIBRARY_PATH=") + 1, "LD_LIBRARY_PATH=%s", ld_library_path);
+
+ envp[3] = ld_lib;
+ } else
+ {
+ envp[3] = NULL;
+ }
+
+ glv_LogInfo("exec process=%s args=%s \n env0:%s env2:%s env3:%s\n",
+ pInfo->exeName, pInfo->processArgs, (envp[0] == NULL) ? "" : envp[0],
+ (envp[2] == NULL) ? "" : envp[2],
+ (envp[3] == NULL) ? "" : envp[3]);
+ extern char **environ;
+ environ = envp;
+ if (execl(pInfo->exeName, pInfo->exeName, pInfo->processArgs, (char *) 0) < 0)
+ {
+ glv_LogError("Failed to spawn process.\n");
+ return FALSE;
+ }
+ }
+#endif
+
+ return TRUE;
+}
+
+void glv_process_info_delete(glv_process_info* pInfo)
+{
+ unsigned int i = 0;
+ if (pInfo->pCaptureThreads != NULL)
+ {
+ for (i = 0; i < pInfo->tracerCount; i++)
+ {
+ glv_platform_delete_thread(&(pInfo->pCaptureThreads[i].recordingThread));
+ }
+ GLV_DELETE(pInfo->pCaptureThreads);
+ }
+
+#ifdef WIN32
+ glv_platform_delete_thread(&(pInfo->watchdogThread));
+#endif
+
+ GLV_DELETE(pInfo->workingDirectory);
+ GLV_DELETE(pInfo->processArgs);
+ GLV_DELETE(pInfo->exeName);
+
+ if (pInfo->pTraceFile != NULL)
+ {
+ fclose(pInfo->pTraceFile);
+ }
+ glv_delete_critical_section(&(pInfo->traceFileCriticalSection));
+}
diff --git a/tools/glave/src/glvcommon/glv_process.h b/tools/glave/src/glvcommon/glv_process.h
new file mode 100644
index 0000000..ecf58f5
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_process.h
@@ -0,0 +1,76 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "glv_platform.h"
+#include "glv_trace_packet_identifiers.h"
+
+typedef struct glv_process_capture_trace_thread_info glv_process_capture_trace_thread_info;
+
+typedef struct glv_process_info
+{
+ char* exeName;
+ char* processArgs;
+ char* workingDirectory;
+ char* traceFilename;
+ FILE* pTraceFile;
+
+ // glvtrace's thread id
+ glv_thread_id parentThreadId;
+
+ GLV_CRITICAL_SECTION traceFileCriticalSection;
+
+ volatile BOOL serverRequestsTermination;
+
+ unsigned int tracerCount;
+ glv_process_capture_trace_thread_info* pCaptureThreads;
+
+ // process id, handle, and main thread
+ glv_process_id processId;
+ glv_process_handle hProcess;
+ glv_thread hThread;
+ glv_thread watchdogThread;
+ char* processLDPreload;
+} glv_process_info;
+
+
+typedef struct glv_process_tracer_dll
+{
+ char * dllPath;
+ BOOL bLoaded;
+ GLV_TRACER_ID tid;
+} glv_process_tracer_dll;
+
+struct glv_process_capture_trace_thread_info
+{
+ glv_thread tracingThread;
+ glv_thread recordingThread;
+ glv_process_info* pProcessInfo;
+ GLV_TRACER_ID tracerId;
+ char* tracerPath;
+};
+
+BOOL glv_process_spawn(glv_process_info* pInfo);
+void glv_process_info_delete(glv_process_info* pInfo);
diff --git a/tools/glave/src/glvcommon/glv_settings.c b/tools/glave/src/glvcommon/glv_settings.c
new file mode 100644
index 0000000..bb530ba
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_settings.c
@@ -0,0 +1,391 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "glv_settings.h"
+
+// local functions
+void glv_SettingInfo_print(const glv_SettingInfo* pSetting);
+
+// ------------------------------------------------------------------------------------------------
+void glv_SettingInfo_print(const glv_SettingInfo* pSetting)
+{
+ if (pSetting->bPrintInHelp)
+ {
+ char * pStrParams;
+ if (pSetting->type == GLV_SETTING_STRING)
+ {
+ pStrParams = "<string>";
+ } else if (pSetting->type == GLV_SETTING_BOOL) {
+ pStrParams = "<BOOL> ";
+ } else if (pSetting->type == GLV_SETTING_UINT) {
+ pStrParams = "<uint> ";
+ } else if (pSetting->type == GLV_SETTING_INT) {
+ pStrParams = "<int> ";
+ } else {
+ pStrParams = "< ??? > ";
+ }
+ printf(" -%s,--%s %s\t: %s\n", pSetting->pShortName, pSetting->pLongName, pStrParams, pSetting->pDesc);
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+void glv_SettingInfo_print_all(const glv_SettingInfo* pSettings, unsigned int num_settings)
+{
+ unsigned int i;
+
+ printf("Available options:\n");
+
+ for (i = 0; i < num_settings; i++)
+ {
+ glv_SettingInfo_print(&(pSettings[i]));
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+BOOL glv_SettingInfo_parse_value(glv_SettingInfo* pSetting, const char* arg)
+{
+ switch(pSetting->type)
+ {
+ case GLV_SETTING_STRING:
+ {
+ glv_free(*((char**)pSetting->pType_data));
+ *((char**)pSetting->pType_data) = glv_allocate_and_copy(arg);
+ }
+ break;
+ case GLV_SETTING_BOOL:
+ {
+ BOOL bTrue = FALSE;
+ bTrue = strncmp(arg, "true", 4) == 0 || strncmp(arg, "TRUE", 4) == 0 || strncmp(arg, "True", 4) == 0;
+ *(BOOL*)pSetting->pType_data = bTrue;
+ }
+ break;
+ case GLV_SETTING_UINT:
+ {
+ if (sscanf(arg, "%u", (unsigned int*)pSetting->pType_data) != 1)
+ {
+ printf("Invalid unsigned int setting: '%s'\n", arg);
+ return FALSE;
+ }
+ }
+ break;
+ case GLV_SETTING_INT:
+ {
+ if (sscanf(arg, "%d", (int*)pSetting->pType_data) != 1)
+ {
+ printf("Invalid int setting: '%s'\n", arg);
+ return FALSE;
+ }
+ }
+ break;
+ default:
+ assert(!"Unhandled setting type");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+// ------------------------------------------------------------------------------------------------
+void glv_SettingInfo_reset_default(glv_SettingInfo* pSetting)
+{
+ assert(pSetting != NULL);
+ switch(pSetting->type)
+ {
+ case GLV_SETTING_STRING:
+ if (pSetting->pType_data != NULL)
+ {
+ glv_free(*((char**)pSetting->pType_data));
+ }
+
+ if (pSetting->pType_default == NULL)
+ {
+ *((char**)pSetting->pType_data) = NULL;
+ }
+ else
+ {
+ *((char**)pSetting->pType_data) = glv_allocate_and_copy(*((const char**)pSetting->pType_default));
+ }
+ break;
+ case GLV_SETTING_BOOL:
+ *(BOOL*)pSetting->pType_data = *(BOOL*)pSetting->pType_default;
+ break;
+ case GLV_SETTING_UINT:
+ *(unsigned int*)pSetting->pType_data = *(unsigned int*)pSetting->pType_default;
+ break;
+ case GLV_SETTING_INT:
+ *(int*)pSetting->pType_data = *(int*)pSetting->pType_default;
+ break;
+ default:
+ assert(!"Unhandled GLV_SETTING_TYPE");
+ break;
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+int glv_SettingInfo_init_from_file(glv_SettingInfo* pSettings, unsigned int num_settings, const char* filename, char** ppOut_remaining_args)
+{
+ FILE* pFile = NULL;
+ int retVal = 0;
+
+ if (filename != NULL)
+ {
+ pFile = fopen(filename, "r");
+ }
+
+ if (pFile == NULL)
+ {
+ glv_LogWarn("Settings file not found: '%s'.\n", filename);
+ }
+ else
+ {
+ char* line = GLV_NEW_ARRAY(char, 1024);
+ if (line == NULL)
+ {
+ printf("Out of memory while reading settings file\n");
+ }
+ else
+ {
+ char name[MAX_PATH];
+ char value[MAX_PATH];
+ while (feof(pFile) == 0 && ferror(pFile) == 0)
+ {
+ line = fgets(line, 1024, pFile);
+ if (line == NULL)
+ {
+ break;
+ }
+
+ // if line ends with a newline, then replace it with a NULL
+ if (line[strlen(line)-1] == '\n')
+ {
+ line[strlen(line)-1] = '\0';
+ }
+
+ // if the line starts with "#" or "//", then consider it a comment and ignore it.
+ // if the first 'word' is only "-- " then the remainder of the line is for application arguments
+ // else first 'word' in line should be a long setting name and the rest of line is value for setting
+ if (line[0] == '#' || (line[0] == '/' && line[1] == '/'))
+ {
+ // its a comment, continue to next loop iteration
+ continue;
+ }
+ else if (strncmp(line, "-- ", 3) == 0 && ppOut_remaining_args != NULL)
+ {
+ // remainder of line is for the application arguments
+ const char* strValue = &line[3];
+ if (*ppOut_remaining_args == NULL || strlen(*ppOut_remaining_args) == 0)
+ {
+ *ppOut_remaining_args = glv_allocate_and_copy(strValue);
+ }
+ else
+ {
+ char* tmp = glv_copy_and_append(*ppOut_remaining_args, " ", &line[3]);
+ glv_free(*ppOut_remaining_args);
+ *ppOut_remaining_args = tmp;
+ }
+ }
+ else if (sscanf(line, "%s = %c", name, value) != 2)
+ {
+ printf("Could not parse settings file due to line: '%s'\n", line);
+ retVal = -1;
+ }
+ else
+ {
+ const char* strValue = &line[strlen(name) + strlen(" = ")];
+
+ // figure out which setting it was
+ unsigned int settingIndex;
+ glv_SettingInfo* pSetting = NULL;
+ for (settingIndex = 0; settingIndex < num_settings; settingIndex++)
+ {
+ pSetting = &pSettings[settingIndex];
+
+ if (strcmp(name, pSetting->pLongName) == 0)
+ {
+ if (glv_SettingInfo_parse_value(&pSettings[settingIndex], strValue) == FALSE)
+ {
+ retVal = -1;
+ }
+ break;
+ }
+ pSetting = NULL;
+ }
+
+ if (pSetting == NULL)
+ {
+ printf("No matching setting found for '%s' in line '%s'\n", name, line);
+ retVal = -1;
+ }
+ }
+
+ if (retVal == -1)
+ {
+ break;
+ }
+ }
+ }
+
+ fclose(pFile);
+ }
+
+ return retVal;
+}
+
+int glv_SettingInfo_init_from_cmdline(glv_SettingInfo* pSettings, unsigned int num_settings, int argc, char* argv[], char** ppOut_remaining_args)
+{
+ int i = 0;
+
+ // update settings based on command line options
+ for (i = 1; i < argc; )
+ {
+ unsigned int settingIndex;
+ int consumed = 0;
+ char* curArg = argv[i];
+
+ // if the arg is only "--" then all following args are for the application;
+ // if the arg starts with "-" then it is referring to a short name;
+ // if the arg starts with "--" then it is referring to a long name.
+ if (strcmp("--", curArg) == 0 && ppOut_remaining_args != NULL)
+ {
+ // all remaining args are for the application
+
+ // increment past the current arg
+ i += 1;
+ consumed++;
+ for (; i < argc; i++)
+ {
+ if (*ppOut_remaining_args == NULL || strlen(*ppOut_remaining_args) == 0)
+ {
+ *ppOut_remaining_args = glv_allocate_and_copy(argv[i]);
+ }
+ else
+ {
+ *ppOut_remaining_args = glv_copy_and_append(*ppOut_remaining_args, " ", argv[i]);
+ }
+ consumed++;
+ }
+ }
+ else
+ {
+ for (settingIndex = 0; settingIndex < num_settings; settingIndex++)
+ {
+ const char* pSettingName = NULL;
+ curArg = argv[i];
+ if (strncmp("--", curArg, 2) == 0)
+ {
+ // long option name
+ pSettingName = pSettings[settingIndex].pLongName;
+ curArg += 2;
+ }
+ else if (strncmp("-", curArg, 1) == 0)
+ {
+ // short option name
+ pSettingName = pSettings[settingIndex].pShortName;
+ curArg += 1;
+ }
+
+ if (pSettingName != NULL && strcmp(curArg, pSettingName) == 0)
+ {
+ if (glv_SettingInfo_parse_value(&pSettings[settingIndex], argv[i+1]))
+ {
+ consumed += 2;
+ }
+ break;
+ }
+ }
+ }
+
+ if (consumed == 0)
+ {
+ printf("Error: Invalid argument found '%s'\n", curArg);
+ glv_SettingInfo_print_all(pSettings, num_settings);
+ glv_SettingInfo_delete(pSettings, num_settings);
+ return -1;
+ }
+
+ i += consumed;
+ }
+
+ return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+int glv_SettingInfo_init(glv_SettingInfo* pSettings, unsigned int num_settings, const char* settingsfile, int argc, char* argv[], char** ppOut_remaining_args)
+{
+ unsigned int u;
+
+ if (pSettings == NULL || num_settings == 0)
+ {
+ assert(!"No need to call glv_SettingInfo_init if the application has no settings");
+ return 0;
+ }
+
+ if (argc == 2 && (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0))
+ {
+ glv_SettingInfo_print_all(pSettings, num_settings);
+ return -1;
+ }
+
+ // Initially, set all options to their defaults
+ for (u = 0; u < num_settings; u++)
+ {
+ glv_SettingInfo_reset_default(&pSettings[u]);
+ }
+
+ // Secondly set options based on settings file
+ if (glv_SettingInfo_init_from_file(pSettings, num_settings, settingsfile, ppOut_remaining_args) == -1)
+ {
+ glv_SettingInfo_print_all(pSettings, num_settings);
+ return -1;
+ }
+
+ // Thirdly set options based on cmd line args
+ if (glv_SettingInfo_init_from_cmdline(pSettings, num_settings, argc, argv, ppOut_remaining_args) == -1)
+ {
+ glv_SettingInfo_print_all(pSettings, num_settings);
+ return -1;
+ }
+
+ return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+void glv_SettingInfo_delete(glv_SettingInfo* pSettings, unsigned int num_settings)
+{
+ unsigned int i;
+
+ // need to delete all strings
+ for (i = 0; i < num_settings; i++)
+ {
+ if (pSettings[i].type == GLV_SETTING_STRING)
+ {
+ if (pSettings[i].pType_data != NULL)
+ {
+ glv_free(*((char**)pSettings[i].pType_data));
+ pSettings[i].pType_data = NULL;
+ }
+ }
+ }
+}
diff --git a/tools/glave/src/glvcommon/glv_settings.h b/tools/glave/src/glvcommon/glv_settings.h
new file mode 100644
index 0000000..864a93d
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_settings.h
@@ -0,0 +1,53 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "glv_common.h"
+
+typedef enum GLV_SETTING_TYPE
+{
+ GLV_SETTING_STRING,
+ GLV_SETTING_BOOL,
+ GLV_SETTING_UINT,
+ GLV_SETTING_INT
+} GLV_SETTING_TYPE;
+
+// ------------------------------------------------------------------------------------------------
+typedef struct glv_SettingInfo
+{
+ const char* const pShortName;
+ const char* const pLongName;
+ GLV_SETTING_TYPE type;
+ void* pType_data;
+ const void * const pType_default;
+ BOOL bPrintInHelp;
+ const char* pDesc;
+} glv_SettingInfo;
+
+int glv_SettingInfo_init(glv_SettingInfo* pSettings, unsigned int num_settings, const char* settingsfile, int argc, char* argv[], char** ppOut_remaining_args);
+void glv_SettingInfo_delete(glv_SettingInfo* pSettings, unsigned int num_settings);
+
+void glv_SettingInfo_print_all(const glv_SettingInfo* pSettings, unsigned int num_settings);
+void glv_SettingInfo_reset_default(glv_SettingInfo* pSetting);
diff --git a/tools/glave/src/glvcommon/glv_trace_packet_identifiers.h b/tools/glave/src/glvcommon/glv_trace_packet_identifiers.h
new file mode 100644
index 0000000..5a9f40e
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_trace_packet_identifiers.h
@@ -0,0 +1,125 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "glv_common.h"
+#include "glv_tracelog.h"
+
+#define GLV_TRACE_FILE_VERSION_1 0x0001
+#define GLV_TRACE_FILE_VERSION GLV_TRACE_FILE_VERSION_1
+#define GLV_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE GLV_TRACE_FILE_VERSION_1
+
+#define GLV_MAX_TRACER_ID_ARRAY_SIZE 16
+
+typedef enum GLV_TRACER_ID
+{
+ GLV_TID_RESERVED = 0,
+ GLV_TID_GL_FPS,
+ GLV_TID_MANTLE,
+ GLV_TID_XGL,
+ GLV_TID_MANTLE_PERF
+ // Max enum must be less than GLV_MAX_TRACER_ID_ARRAY_SIZE
+} GLV_TRACER_ID;
+
+typedef struct GLV_TRACER_REPLAYER_INFO
+{
+ GLV_TRACER_ID tracerId;
+ BOOL needsReplayer;
+ const char* const replayerLibraryName;
+} GLV_TRACER_REPLAYER_INFO;
+
+// The index here should match the value of the GLV_TRACER_ID
+static const GLV_TRACER_REPLAYER_INFO gs_tracerReplayerInfo[GLV_MAX_TRACER_ID_ARRAY_SIZE] = {
+ {GLV_TID_RESERVED, FALSE, ""},
+ {GLV_TID_GL_FPS, FALSE, ""},
+ {GLV_TID_MANTLE, TRUE, GLV_LIBRARY_NAME(glvreplay_mantle)},
+ {GLV_TID_XGL, TRUE, GLV_LIBRARY_NAME(glvreplay_xgl)},
+ {GLV_TID_MANTLE_PERF, FALSE, ""},
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+ {GLV_TID_RESERVED, FALSE, ""}, // this can be updated as new tracers are added
+};
+
+typedef enum _GLV_TRACE_PACKET_ID
+{
+ GLV_TPI_MESSAGE,
+ GLV_TPI_MARKER_CHECKPOINT,
+ GLV_TPI_MARKER_API_BOUNDARY,
+ GLV_TPI_MARKER_API_GROUP_BEGIN,
+ GLV_TPI_MARKER_API_GROUP_END,
+ GLV_TPI_MARKER_TERMINATE_PROCESS,
+ GLV_TPI_BEGIN_API_HERE // this enum should always be the last in the list. Feel free to insert new ID above this one.
+} GLV_TRACE_PACKET_ID;
+
+typedef struct {
+ uint16_t trace_file_version;
+ uint32_t uuid[4];
+ uint64_t first_packet_offset; // will be size of header including size of tracer_id_array and state_snapshot_path/binary
+ uint8_t tracer_count; // number of tracers referenced in this trace file
+ uint8_t tracer_id_array[GLV_MAX_TRACER_ID_ARRAY_SIZE]; // array of tracer_ids which are referenced in the trace file
+ uint8_t contains_state_snapshot; // bool (0 = false, 1 = true)
+ uint32_t state_snapshot_size; // either length of state_snapshot_path or bytecount of state_snapshot_binary
+ intptr_t state_snapshot_path; // char* array text path to snapshot file
+ intptr_t state_snapshot_binary; // byte array binary blob
+ // unsigned int pointer_sizes; // indicates whether app is 32-bit or 64-bit
+} glv_trace_file_header;
+
+typedef struct {
+ uint64_t size; // total size, including extra data, needed to get to the next packet_header
+ uint64_t global_packet_index;
+ uint8_t tracer_id; // TODO: need to uniquely identify tracers in a way that is known by the replayer
+ uint16_t packet_id; // GLV_TRACE_PACKET_ID (or one of the api-specific IDs)
+ uint64_t entrypoint_begin_time;
+ uint64_t entrypoint_end_time;
+ uint64_t next_buffers_offset; // used for tracking the addition of buffers to the trace packet
+ uintptr_t pBody; // points to the body of the packet
+} glv_trace_packet_header;
+
+typedef struct {
+ glv_trace_packet_header* pHeader;
+ TraceLogLevel type;
+ uint32_t length;
+ char* message;
+} glv_trace_packet_message;
+
+typedef struct {
+ glv_trace_packet_header* pHeader;
+ unsigned int length;
+ char* label;
+} glv_trace_packet_marker_checkpoint;
+
+typedef glv_trace_packet_marker_checkpoint glv_trace_packet_marker_api_boundary;
+typedef glv_trace_packet_marker_checkpoint glv_trace_packet_marker_api_group_begin;
+typedef glv_trace_packet_marker_checkpoint glv_trace_packet_marker_api_group_end;
+
+typedef GLV_TRACER_ID (APIENTRY *funcptr_GLV_GetTracerId)();
diff --git a/tools/glave/src/glvcommon/glv_trace_packet_utils.c b/tools/glave/src/glvcommon/glv_trace_packet_utils.c
new file mode 100644
index 0000000..d715c65
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_trace_packet_utils.c
@@ -0,0 +1,264 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glv_trace_packet_utils.h"
+#include "glv_interconnect.h"
+#include "glv_filelike.h"
+#ifdef WIN32
+#include <rpc.h>
+#pragma comment (lib, "Rpcrt4.lib")
+#endif
+
+#if defined(PLATFORM_LINUX)
+#include <fcntl.h>
+#include <time.h>
+#endif
+
+static uint64_t g_packet_index = 0;
+static int g_reliable_rdtsc = -1;
+
+void glv_gen_uuid(uint32_t* pUuid)
+{
+ uint32_t buf[] = { 0xABCDEF, 0x12345678, 0xFFFECABC, 0xABCDDEF0 };
+ glv_platform_rand_s(buf, sizeof(buf)/sizeof(uint32_t));
+
+ pUuid[0] = buf[0];
+ pUuid[1] = buf[1];
+ pUuid[2] = buf[2];
+ pUuid[3] = buf[3];
+}
+
+BOOL glv_init_time()
+{
+#if defined(PLATFORM_LINUX)
+ if (g_reliable_rdtsc == -1)
+ {
+ g_reliable_rdtsc = 0;
+
+ FILE *file = fopen("/sys/devices/system/clocksource/clocksource0/current_clocksource", "r");
+ if (file)
+ {
+ char buf[64];
+
+ if (fgets(buf, sizeof(buf), file))
+ {
+ if (buf[0] == 't' && buf[1] == 's' && buf[2] == 'c')
+ g_reliable_rdtsc = 1;
+ }
+
+ fclose(file);
+ }
+ }
+
+ // return true for reliable rdtsc.
+ return !!g_reliable_rdtsc;
+#else
+ return TRUE;
+#endif
+}
+
+uint64_t glv_get_time()
+{
+#if defined(VOGL_USE_LINUX_API)
+ extern int g_reliable_rdtsc;
+ if (g_reliable_rdtsc == -1)
+ init_rdtsc();
+ if (g_reliable_rdtsc == 0)
+ {
+ //$ TODO: Should just use SDL_GetPerformanceCounter?
+ struct timespec time;
+ clock_gettime(CLOCK_MONOTONIC, &time);
+ return ((uint64_t)time.tv_sec * 1000000000) + time.tv_nsec;
+ }
+#elif defined(COMPILER_GCCLIKE)
+ unsigned int hi, lo;
+ __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
+ return ((uint64_t)hi << 32) | lo;
+#else
+ return __rdtsc();
+#endif
+}
+
+//=============================================================================
+// trace file header
+
+glv_trace_file_header* glv_create_trace_file_header()
+{
+ glv_trace_file_header* pHeader = GLV_NEW(glv_trace_file_header);
+ memset(pHeader, 0, sizeof(glv_trace_file_header));
+ pHeader->trace_file_version = GLV_TRACE_FILE_VERSION;
+ glv_gen_uuid(pHeader->uuid);
+ pHeader->contains_state_snapshot = FALSE;
+ pHeader->state_snapshot_path = (intptr_t)NULL;
+ pHeader->state_snapshot_binary = (intptr_t)NULL;
+
+ return pHeader;
+}
+
+void glv_delete_trace_file_header(glv_trace_file_header** ppHeader)
+{
+ glv_free(*ppHeader);
+ *ppHeader = NULL;
+}
+
+//=============================================================================
+// Methods for creating, populating, and writing trace packets
+
+glv_trace_packet_header* glv_create_trace_packet(uint8_t tracer_id, uint16_t packet_id, uint64_t packet_size, uint64_t additional_buffers_size)
+{
+ // Always allocate at least enough space for the packet header
+ uint64_t total_packet_size = sizeof(glv_trace_packet_header) + packet_size + additional_buffers_size;
+ void* pMem = glv_malloc((size_t)total_packet_size);
+
+ glv_trace_packet_header* pHeader = (glv_trace_packet_header*)pMem;
+ pHeader->size = total_packet_size;
+ pHeader->global_packet_index = g_packet_index++;
+ pHeader->tracer_id = tracer_id;
+ pHeader->packet_id = packet_id;
+ pHeader->entrypoint_begin_time = glv_get_time();
+ pHeader->entrypoint_end_time = 0;
+ pHeader->next_buffers_offset = sizeof(glv_trace_packet_header) + packet_size; // initial offset is from start of header to after the packet body
+ if (total_packet_size > sizeof(glv_trace_packet_header))
+ {
+ pHeader->pBody = (uintptr_t)(((char*)pMem) + sizeof(glv_trace_packet_header));
+ }
+ return pHeader;
+}
+
+void glv_delete_trace_packet(glv_trace_packet_header** ppHeader)
+{
+ if (ppHeader == NULL)
+ return;
+ if (*ppHeader == NULL)
+ return;
+
+ GLV_DELETE(*ppHeader);
+ *ppHeader = NULL;
+}
+
+void* glv_trace_packet_get_new_buffer_address(glv_trace_packet_header* pHeader, uint64_t byteCount)
+{
+ void* pBufferStart;
+ assert(byteCount > 0);
+ assert(pHeader->size >= pHeader->next_buffers_offset + byteCount);
+ if (pHeader->size < pHeader->next_buffers_offset + byteCount || byteCount == 0)
+ {
+ // not enough memory left in packet to hold buffer
+ // or request is for 0 bytes
+ return NULL;
+ }
+
+ pBufferStart = (void*)((char*)pHeader + pHeader->next_buffers_offset);
+ pHeader->next_buffers_offset += byteCount;
+ return pBufferStart;
+}
+
+void glv_add_buffer_to_trace_packet(glv_trace_packet_header* pHeader, void** ptr_address, uint64_t size, const void* pBuffer)
+{
+ assert(ptr_address != NULL);
+ if (pBuffer == NULL || size == 0)
+ {
+ *ptr_address = NULL;
+ }
+ else
+ {
+ // set ptr to the location of the added buffer
+ *ptr_address = glv_trace_packet_get_new_buffer_address(pHeader, size);
+
+ // copy buffer to the location
+ memcpy(*ptr_address, pBuffer, (size_t)size);
+ }
+}
+
+void glv_finalize_buffer_address(glv_trace_packet_header* pHeader, void** ptr_address)
+{
+ assert(ptr_address != NULL);
+
+ if (*ptr_address != NULL)
+ {
+ // turn ptr into an offset from the packet body
+ uint64_t offset = (uint64_t)*ptr_address - (uint64_t) (pHeader->pBody);
+ *ptr_address = (void*)offset;
+ }
+}
+
+void glv_finalize_trace_packet(glv_trace_packet_header* pHeader)
+{
+ pHeader->entrypoint_end_time = glv_get_time();
+}
+
+void glv_write_trace_packet(const glv_trace_packet_header* pHeader, FileLike* pFile)
+{
+ glv_FileLike_WriteRaw(pFile, pHeader, (size_t)pHeader->size);
+}
+
+//=============================================================================
+// Methods for Reading and interpretting trace packets
+
+glv_trace_packet_header* glv_read_trace_packet(FileLike* pFile)
+{
+ // read size
+ // allocate space
+ // offset to after size
+ // read the rest of the packet
+ uint64_t total_packet_size = 0;
+ void* pMem;
+ glv_trace_packet_header* pHeader;
+
+ if (glv_FileLike_ReadRaw(pFile, &total_packet_size, sizeof(uint64_t)) == FALSE)
+ {
+ return NULL;
+ }
+
+ // allocate space
+ pMem = glv_malloc((size_t)total_packet_size);
+ pHeader = (glv_trace_packet_header*)pMem;
+
+ if (pHeader != NULL)
+ {
+ pHeader->size = total_packet_size;
+ if (glv_FileLike_ReadRaw(pFile, (char*)pHeader + sizeof(uint64_t), (size_t)total_packet_size - sizeof(uint64_t)) == FALSE)
+ {
+ return NULL;
+ }
+
+ pHeader->pBody = (uintptr_t)pHeader + sizeof(glv_trace_packet_header);
+ }
+
+ return pHeader;
+}
+
+void* glv_trace_packet_interpret_buffer_pointer(glv_trace_packet_header* pHeader, intptr_t ptr_variable)
+{
+ // the pointer variable actually contains a byte offset from the packet body to the start of the buffer.
+ uint64_t offset = ptr_variable;
+ void* buffer_location;
+
+ // if the offset is 0, then we know the pointer to the buffer was NULL, so no buffer exists and we return NULL.
+ if (offset == 0)
+ return NULL;
+
+ buffer_location = (char*)(pHeader->pBody) + offset;
+ return buffer_location;
+}
diff --git a/tools/glave/src/glvcommon/glv_trace_packet_utils.h b/tools/glave/src/glvcommon/glv_trace_packet_utils.h
new file mode 100644
index 0000000..f77b87b
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_trace_packet_utils.h
@@ -0,0 +1,149 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#include "glv_trace_packet_identifiers.h"
+#include "glv_filelike.h"
+#include "glv_memory.h"
+#include "glv_process.h"
+
+// pUuid is expected to be an array of 4 unsigned ints
+void glv_gen_uuid(uint32_t* pUuid);
+
+BOOL glv_init_time();
+uint64_t glv_get_time();
+
+//=============================================================================
+// trace file header
+
+// there is a file header at the start of every trace file
+glv_trace_file_header* glv_create_trace_file_header();
+
+// deletes the trace file header and sets pointer to NULL
+void glv_delete_trace_file_header(glv_trace_file_header** ppHeader);
+
+static FILE* glv_write_trace_file_header(glv_process_info* pProcInfo)
+{
+ FILE* tracefp = NULL;
+ unsigned int index = 0;
+ glv_trace_file_header* pHeader = NULL;
+ size_t items_written = 0;
+ assert(pProcInfo != NULL);
+
+ // open trace file
+ tracefp = fopen(pProcInfo->traceFilename, "wb");
+ if (tracefp == NULL)
+ {
+ glv_LogError("Cannot open trace file for writing %s\n", pProcInfo->traceFilename);
+ return tracefp;
+ }
+
+ // populate header information
+ pHeader = glv_create_trace_file_header();
+ pHeader->first_packet_offset = sizeof(glv_trace_file_header);
+ pHeader->tracer_count = pProcInfo->tracerCount;
+
+ for (index = 0; index < pProcInfo->tracerCount; index++)
+ {
+ pHeader->tracer_id_array[index] = pProcInfo->pCaptureThreads[index].tracerId;
+ }
+
+ pHeader->contains_state_snapshot = FALSE;
+ pHeader->state_snapshot_size = 0;
+ pHeader->state_snapshot_binary = (intptr_t) NULL;
+ pHeader->state_snapshot_path = (intptr_t) NULL;
+
+ // create critical section
+ glv_create_critical_section(&pProcInfo->traceFileCriticalSection);
+
+ // write header into file
+ glv_enter_critical_section(&pProcInfo->traceFileCriticalSection);
+ items_written = fwrite(pHeader, sizeof(glv_trace_file_header), 1, tracefp);
+ glv_leave_critical_section(&pProcInfo->traceFileCriticalSection);
+ if (items_written != 1)
+ {
+ glv_LogError("Failed to write trace file header\n");
+ }
+ glv_delete_trace_file_header(&pHeader);
+ return tracefp;
+};
+
+
+//=============================================================================
+// trace packets
+// There is a trace_packet_header before every trace_packet_body.
+// Additional buffers will come after the trace_packet_body.
+
+//=============================================================================
+// Methods for creating, populating, and writing trace packets
+
+// \param packet_size should include the total bytes for the specific type of packet, and any additional buffers needed by the packet.
+// The size of the header will be added automatically within the function.
+glv_trace_packet_header* glv_create_trace_packet(uint8_t tracer_id, uint16_t packet_id, uint64_t packet_size, uint64_t additional_buffers_size);
+
+// deletes a trace packet and sets pointer to NULL
+void glv_delete_trace_packet(glv_trace_packet_header** ppHeader);
+
+// gets the next address available to write a buffer into the packet
+void* glv_trace_packet_get_new_buffer_address(glv_trace_packet_header* pHeader, uint64_t byteCount);
+
+// copies buffer data into a trace packet at the specified offset (from the end of the header).
+// it is up to the caller to ensure that buffers do not overlap.
+void glv_add_buffer_to_trace_packet(glv_trace_packet_header* pHeader, void** ptr_address, uint64_t size, const void* pBuffer);
+
+// converts buffer pointers into byte offset so that pointer can be interpretted after being read into memory
+void glv_finalize_buffer_address(glv_trace_packet_header* pHeader, void** ptr_address);
+
+//void initialize_trace_packet_header(glv_trace_packet_header* pHeader, uint8_t tracer_id, uint16_t packet_id, uint64_t total_packet_size);
+void glv_finalize_trace_packet(glv_trace_packet_header* pHeader);
+
+// Write the trace packet to the filelike thing.
+// This has no knowledge of the details of the packet other than its size.
+void glv_write_trace_packet(const glv_trace_packet_header* pHeader, FileLike* pFile);
+
+//=============================================================================
+// Methods for Reading and interpretting trace packets
+
+// Reads in the trace packet header, the body of the packet, and additional buffers
+glv_trace_packet_header* glv_read_trace_packet(FileLike* pFile);
+
+// converts a pointer variable that is currently byte offset into a pointer to the actual offset location
+void* glv_trace_packet_interpret_buffer_pointer(glv_trace_packet_header* pHeader, intptr_t ptr_variable);
+
+//=============================================================================
+// trace packet message
+// Interpretting a trace_packet_message should be done only when:
+// 1) a trace_packet is first created and most of the contents are empty.
+// 2) immediately after the packet was read from memory
+// All other conversions of the trace packet body from the header should
+// be performed using a C-style cast.
+static glv_trace_packet_message* glv_interpret_body_as_trace_packet_message(glv_trace_packet_header* pHeader)
+{
+ glv_trace_packet_message* pPacket = (glv_trace_packet_message*)pHeader->pBody;
+ // update pointers
+ pPacket->pHeader = pHeader;
+ pPacket->message = (char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->message);
+ return pPacket;
+}
diff --git a/tools/glave/src/glvcommon/glv_tracelog.c b/tools/glave/src/glvcommon/glv_tracelog.c
new file mode 100644
index 0000000..e3b2fc3
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_tracelog.c
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+
+#ifdef _DEBUG
+#include "glv_common.h" // for OutputDebugString
+#endif
+
+#include "glv_tracelog.h"
+#include "glv_trace_packet_utils.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+// filelike thing that is used for outputting trace messages
+static FileLike* g_pFileOut = NULL;
+
+// filelike thing that is used for outputting log messages
+static FileLike* g_pLogFile = NULL;
+
+GLV_TRACER_ID g_tracelog_tracer_id = GLV_TID_RESERVED;
+
+void glv_tracelog_set_log_file(FileLike* pFileLike)
+{
+ g_pLogFile = pFileLike;
+}
+
+void glv_tracelog_delete_log_file()
+{
+ if (g_pLogFile != NULL)
+ {
+ fflush(g_pLogFile->mFile);
+ GLV_DELETE(g_pLogFile);
+ g_pLogFile = NULL;
+ }
+}
+
+void glv_trace_set_trace_file(FileLike* pFileLike)
+{
+ g_pFileOut = pFileLike;
+}
+
+FileLike* glv_trace_get_trace_file()
+{
+ return g_pFileOut;
+}
+
+void glv_tracelog_set_tracer_id(uint8_t tracerId)
+{
+ g_tracelog_tracer_id = (GLV_TRACER_ID)tracerId;
+}
+
+void TraceGuts(TraceLogLevel _level, BOOL _log, const char* _fmt, va_list _args)
+{
+#if defined(WIN32)
+ int requiredLength = _vscprintf(_fmt, _args) + 1;
+#elif defined(PLATFORM_LINUX)
+ int requiredLength;
+ va_list argcopy;
+ va_copy(argcopy, _args);
+ requiredLength = vsnprintf(NULL, 0, _fmt, argcopy) + 1;
+ va_end(argcopy);
+#endif
+
+ if (_log)
+ {
+ char* message = (char*)glv_malloc(requiredLength);
+#if defined(WIN32)
+ _vsnprintf_s(message, requiredLength, requiredLength - 1, _fmt, _args);
+#elif defined(PLATFORM_LINUX)
+ vsnprintf(message, requiredLength, _fmt, _args);
+#endif
+ glv_PrintTraceMessage(_level, message);
+ glv_free(message);
+ }
+ else if (g_pFileOut != NULL)
+ {
+ glv_trace_packet_header* pHeader = glv_create_trace_packet(g_tracelog_tracer_id, GLV_TPI_MESSAGE, sizeof(glv_trace_packet_message), requiredLength);
+ glv_trace_packet_message* pPacket = glv_interpret_body_as_trace_packet_message(pHeader);
+ pPacket->type = _level;
+ pPacket->length = requiredLength;
+ pPacket->message = (char*)glv_trace_packet_get_new_buffer_address(pHeader, requiredLength);
+#if defined(WIN32)
+ _vsnprintf_s(pPacket->message, requiredLength, requiredLength - 1, _fmt, _args);
+#elif defined(PLATFORM_LINUX)
+ vsnprintf(pPacket->message, requiredLength, _fmt, _args);
+#endif
+
+ glv_finalize_buffer_address(pHeader, (void**)&pPacket->message);
+ glv_finalize_trace_packet(pHeader);
+
+ glv_write_trace_packet(pHeader, g_pFileOut);
+ glv_delete_trace_packet(&pHeader);
+ }
+}
+
+void glv_TraceVerbose(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLVerbose, FALSE, fmt, args);
+ va_end(args);
+}
+
+void glv_TraceInfo(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLInfo, FALSE, fmt, args);
+ va_end(args);
+}
+
+void glv_TraceWarn(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLWarn, FALSE, fmt, args);
+ va_end(args);
+}
+
+void glv_TraceError(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLError, FALSE, fmt, args);
+ va_end(args);
+}
+
+void glv_LogDebug(const char* fmt, ...)
+{
+#ifdef _DEBUG
+ // same as LogInfo
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLInfo, TRUE, fmt, args);
+ va_end(args);
+#endif
+}
+
+void glv_LogVerbose(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLVerbose, TRUE, fmt, args);
+ va_end(args);
+}
+
+void glv_LogInfo(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLInfo, TRUE, fmt, args);
+ va_end(args);
+}
+
+void glv_LogWarn(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLWarn, TRUE, fmt, args);
+ va_end(args);
+}
+
+void glv_LogError(const char* fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ TraceGuts(TLLError, TRUE, fmt, args);
+ va_end(args);
+}
+
+// To display the trace messages to stdout.
+void glv_PrintTraceMessage(int _level, const char* _body)
+{
+ const char* levelHeader = "Unknown";
+ switch (_level)
+ {
+ case TLLVerbose: levelHeader = "Verbose"; break;
+ case TLLInfo: levelHeader = "Info"; break;
+ case TLLWarn: levelHeader = "Warning"; break;
+ case TLLError: levelHeader = "ERROR"; break;
+ default:
+ assert(0);
+ break;
+ };
+
+ if (g_pLogFile != NULL)
+ {
+ glv_FileLike_WriteRaw(g_pLogFile, _body, strlen(_body));
+ }
+ else
+ {
+ printf("%s: %s", levelHeader, _body);
+ }
+
+#if defined(_DEBUG) && defined(WIN32)
+ OutputDebugString(_body);
+#endif
+
+}
diff --git a/tools/glave/src/glvcommon/glv_tracelog.h b/tools/glave/src/glvcommon/glv_tracelog.h
new file mode 100644
index 0000000..d8d250b
--- /dev/null
+++ b/tools/glave/src/glvcommon/glv_tracelog.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct FileLike FileLike;
+
+typedef enum {
+ TLLVerbose = 0,
+ TLLInfo,
+ TLLWarn,
+ TLLError
+} TraceLogLevel;
+
+void glv_tracelog_set_log_file(FileLike* pFileLike);
+void glv_tracelog_delete_log_file();
+
+void glv_trace_set_trace_file(FileLike* pFileLike);
+FileLike* glv_trace_get_trace_file();
+void glv_tracelog_set_tracer_id(uint8_t tracerId);
+
+// Inserts log of the appropriate level into the trace so it can be displayed later.
+void glv_TraceVerbose(const char* fmt, ...);
+void glv_TraceInfo(const char* fmt, ...);
+void glv_TraceWarn(const char* fmt, ...);
+void glv_TraceError(const char* fmt, ...);
+
+// These are only output in debug builds
+void glv_LogDebug(const char* fmt, ...);
+
+// These messages are displayed to stdout. During capture, Log messages should only be
+// emitted by glvtrace--any logging from the tracee should come in the form of Trace*, above.
+void glv_LogVerbose(const char* fmt, ...);
+void glv_LogInfo(const char* fmt, ...);
+void glv_LogWarn(const char* fmt, ...);
+void glv_LogError(const char* fmt, ...);
+
+// To display the trace messages to stdout.
+void glv_PrintTraceMessage(int _level, const char* _body);
+
+/*
+#define Once(_call) \
+ do { \
+ static bool once = true; \
+ if (once) { \
+ _call; \
+ once = false; \
+ } \
+ } while (0)
+*/
diff --git a/tools/glave/src/glvcommon/wintypes.h b/tools/glave/src/glvcommon/wintypes.h
new file mode 100644
index 0000000..b708923
--- /dev/null
+++ b/tools/glave/src/glvcommon/wintypes.h
@@ -0,0 +1,77 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+#if defined __linux__
+#include <stdint.h>
+#include <stddef.h>
+typedef void * LPVOID;
+typedef void * PVOID;
+typedef void VOID;
+typedef char CHAR;
+typedef char TCHAR;
+typedef long LONG;
+typedef unsigned long ULONG;
+typedef int BOOL;
+typedef size_t SIZE_T;
+typedef unsigned long DWORD;
+typedef unsigned char BYTE;
+typedef unsigned char *PBYTE;
+typedef unsigned short USHORT;
+typedef unsigned char UCHAR;
+typedef unsigned short WORD;
+typedef DWORD * DWORD_PTR;
+typedef DWORD *PDWORD;
+typedef DWORD_PTR *PDWORD_PTR;
+typedef int32_t INT32;
+typedef int64_t LONG64;
+typedef uint64_t ULONG64;
+typedef const char * PCSTR;
+typedef const wchar_t * PCWSTR;
+#ifndef MAX_PATH
+#include <limits.h>
+#ifndef PATH_MAX
+#define MAX_PATH 4096
+#else
+#define MAX_PATH PATH_MAX
+#endif
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef min
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+#ifndef max
+#define max(a,b) (((a) < (b)) ? (b) : (a))
+#endif
+#elif WIN32
+#include <windows.h>
+#endif
+
diff --git a/tools/glave/src/glvinception/CMakeLists.txt b/tools/glave/src/glvinception/CMakeLists.txt
new file mode 100644
index 0000000..865119a
--- /dev/null
+++ b/tools/glave/src/glvinception/CMakeLists.txt
@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 2.8)
+project(glvinception)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glvinception.c
+)
+
+set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
+
+include_directories(
+ ${SRC_DIR}
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/glvtrace
+ ${SRC_DIR}/thirdparty
+)
+
+add_library(${PROJECT_NAME} SHARED ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+ glvcommon
+)
+
+build_options_finalize()
+
+set_target_properties(glvinception PROPERTIES LINKER_LANGUAGE C)
diff --git a/tools/glave/src/glvinception/glvinception.c b/tools/glave/src/glvinception/glvinception.c
new file mode 100644
index 0000000..d79d12c
--- /dev/null
+++ b/tools/glave/src/glvinception/glvinception.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 "glv_common.h"
+#include <stdio.h>
+
+GLVTRACER_EXIT TrapExit(void)
+{
+ glv_LogInfo("atExit occurred.\n");
+}
+
+GLVTRACER_ENTRY _Load(void)
+{
+ if (glv_is_loaded_into_glvtrace() == FALSE)
+ {
+ // If you need to debug startup, build with this set to true, then attach and change it to false.
+ #ifdef _DEBUG
+ BOOL debugStartup = FALSE;
+ while (debugStartup);
+ #endif
+
+ // register exit handler
+ atexit(TrapExit);
+
+ glv_LogInfo("Hooks attached!\n");
+ }
+}
+
+GLVTRACER_LEAVE _Unload(void)
+{
+ if (glv_is_loaded_into_glvtrace() == FALSE)
+ {
+ // detach and unload
+ glv_LogInfo("Hooks detached!\n");
+ }
+}
+
+#if defined(WIN32)
+BOOL APIENTRY DllMain( HMODULE hModule,
+ DWORD ul_reason_for_call,
+ LPVOID lpReserved
+ )
+
+{
+ hModule;
+ lpReserved;
+
+ switch (ul_reason_for_call)
+ {
+ case DLL_PROCESS_ATTACH:
+ {
+ _Load();
+ break;
+ }
+ case DLL_PROCESS_DETACH:
+ {
+ _Unload();
+ break;
+ }
+ default:
+ break;
+ }
+ return TRUE;
+}
+#endif
diff --git a/tools/glave/src/glvreplay/CMakeLists.txt b/tools/glave/src/glvreplay/CMakeLists.txt
new file mode 100644
index 0000000..3fffb97
--- /dev/null
+++ b/tools/glave/src/glvreplay/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 2.8)
+project(glvreplay)
+
+include("${SRC_DIR}/build_options.cmake")
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glvreplay_factory.h
+ glvreplay_seq.h
+ glvreplay_window.h
+ glvreplay_main.cpp
+ glvreplay_seq.cpp
+ glvreplay_factory.cpp
+)
+
+include_directories(
+ ${SRC_DIR}/glvreplay
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/thirdparty
+)
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+target_link_libraries(${PROJECT_NAME}
+ getopt_bundled
+ glvcommon
+)
+
+build_options_finalize()
diff --git a/tools/glave/src/glvreplay/glvreplay_factory.cpp b/tools/glave/src/glvreplay/glvreplay_factory.cpp
new file mode 100644
index 0000000..d695075
--- /dev/null
+++ b/tools/glave/src/glvreplay/glvreplay_factory.cpp
@@ -0,0 +1,85 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include "glvreplay_factory.h"
+#include "glv_trace_packet_identifiers.h"
+
+namespace glv_replay {
+
+glv_trace_packet_replay_library* ReplayFactory::Create(uint8_t tracerId)
+{
+ glv_trace_packet_replay_library* pReplayer = NULL;
+ void* pLibrary = NULL;
+ char* exeDir = glv_platform_get_current_executable_directory();
+
+ const GLV_TRACER_REPLAYER_INFO* pReplayerInfo = &(gs_tracerReplayerInfo[tracerId]);
+
+ if (pReplayerInfo->tracerId != tracerId)
+ {
+ glv_LogError("Replayer info for TracerId (%d) failed consistency check.\n", tracerId);
+ assert(!"TracerId in GLV_TRACER_REPLAYER_INFO does not match the requested tracerId. The array needs to be corrected.");
+ }
+ else if (pReplayerInfo->needsReplayer == TRUE)
+ {
+ char* replayerPath = glv_copy_and_append(exeDir,"/", pReplayerInfo->replayerLibraryName);
+ pLibrary = glv_platform_open_library(replayerPath);
+ if (pLibrary == NULL) glv_LogError("Failed to load replayer '%s.'\n", replayerPath);
+ glv_free(replayerPath);
+ }
+ else
+ {
+ glv_LogError("A replayer was requested for TracerId (%d), but it does not require a replayer.\n", tracerId);
+ assert(!"Invalid TracerId supplied to ReplayFactory");
+ }
+
+ glv_free(exeDir);
+
+ if (pLibrary != NULL)
+ {
+ pReplayer = GLV_NEW(glv_trace_packet_replay_library);
+ assert(pReplayer != NULL);
+ pReplayer->pLibrary = pLibrary;
+ pReplayer->Initialize = (funcptr_glvreplayer_initialize)glv_platform_get_library_entrypoint(pLibrary, "Initialize");
+ pReplayer->Deinitialize = (funcptr_glvreplayer_deinitialize)glv_platform_get_library_entrypoint(pLibrary, "Deinitialize");
+ pReplayer->Replay = (funcptr_glvreplayer_replay)glv_platform_get_library_entrypoint(pLibrary, "Replay");
+ assert(pReplayer->Initialize != NULL);
+ assert(pReplayer->Deinitialize != NULL);
+ assert(pReplayer->Replay != NULL);
+ }
+
+ return pReplayer;
+}
+
+void ReplayFactory::Destroy(glv_trace_packet_replay_library** ppReplayer)
+{
+ assert (ppReplayer != NULL);
+ assert (*ppReplayer != NULL);
+ glv_platform_close_library((*ppReplayer)->pLibrary);
+ GLV_DELETE(*ppReplayer);
+ *ppReplayer = NULL;
+}
+
+
+} // namespace glv_replay
diff --git a/tools/glave/src/glvreplay/glvreplay_factory.h b/tools/glave/src/glvreplay/glvreplay_factory.h
new file mode 100644
index 0000000..15fc3fb
--- /dev/null
+++ b/tools/glave/src/glvreplay/glvreplay_factory.h
@@ -0,0 +1,63 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+extern "C" {
+#include "glv_common.h"
+#include "glv_trace_packet_identifiers.h"
+}
+#include "glvreplay_window.h"
+
+namespace glv_replay {
+
+enum GLV_REPLAY_RESULT
+{
+ GLV_REPLAY_SUCCESS = 0,
+ GLV_REPLAY_ERROR, // internal error unrelated to the specific packet
+ GLV_REPLAY_INVALID_ID, // packet_id invalid
+ GLV_REPLAY_BAD_RETURN, // replay return value != trace return value
+ GLV_REPLAY_CALL_ERROR, // replaying call caused an error
+ GLV_REPLAY_INVALID_PARAMS, // trace file parameters are invalid
+};
+
+// entrypoints that must be exposed by each replayer library
+typedef int (*funcptr_glvreplayer_initialize)(glv_replay::Display* pDisplay, unsigned int debugLevel);
+typedef void (*funcptr_glvreplayer_deinitialize)();
+typedef glv_replay::GLV_REPLAY_RESULT (*funcptr_glvreplayer_replay)(glv_trace_packet_header* pPacket);
+
+struct glv_trace_packet_replay_library
+{
+ void* pLibrary;
+ funcptr_glvreplayer_initialize Initialize;
+ funcptr_glvreplayer_deinitialize Deinitialize;
+ funcptr_glvreplayer_replay Replay;
+};
+
+class ReplayFactory {
+public:
+ glv_trace_packet_replay_library *Create(uint8_t tracerId);
+ void Destroy(glv_trace_packet_replay_library** ppReplayer);
+};
+} // namespace glv_replay
diff --git a/tools/glave/src/glvreplay/glvreplay_main.cpp b/tools/glave/src/glvreplay/glvreplay_main.cpp
new file mode 100644
index 0000000..19972f4
--- /dev/null
+++ b/tools/glave/src/glvreplay/glvreplay_main.cpp
@@ -0,0 +1,243 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include <stdio.h>
+extern "C" {
+#include "glv_common.h"
+#include "glv_tracelog.h"
+#include "glv_filelike.h"
+#include "glv_trace_packet_utils.h"
+}
+#include "glvreplay_factory.h"
+#include "glvreplay_seq.h"
+#include "glvreplay_window.h"
+#include "getopt/getopt.h"
+
+const static char *shortOptions = "hb";
+
+enum {
+ DEBUG_OPT = 1
+};
+const static struct option longOptions[] = {
+ {"help", no_argument, 0, 'h'},
+ {"benchmark", no_argument, 0, 'b'},
+ {"debug", required_argument, 0, DEBUG_OPT},
+ //TODO add more options
+ {0, 0, 0, 0}};
+
+static void usage(const char *argv0)
+{
+ glv_LogInfo("%s [options] [trace file]\n",argv0);
+ glv_LogInfo("-h | --help print usage\n");
+ glv_LogInfo("-d debug_level 0-N higher is more debug features\n");
+ //TODO add details
+}
+
+namespace glv_replay {
+int main_loop(Sequencer &seq, glv_trace_packet_replay_library *replayerArray[])
+{
+ int err = 0;
+ glv_trace_packet_header *packet;
+ unsigned int res;
+ glv_trace_packet_replay_library *replayer;
+ glv_trace_packet_message* msgPacket;
+
+ while ((packet = seq.get_next_packet()) != NULL)
+ {
+ switch (packet->packet_id) {
+ case GLV_TPI_MESSAGE:
+ msgPacket = glv_interpret_body_as_trace_packet_message(packet);
+ glv_PrintTraceMessage(msgPacket->type, msgPacket->message);
+ break;
+ case GLV_TPI_MARKER_CHECKPOINT:
+ break;
+ case GLV_TPI_MARKER_API_BOUNDARY:
+ break;
+ case GLV_TPI_MARKER_API_GROUP_BEGIN:
+ break;
+ case GLV_TPI_MARKER_API_GROUP_END:
+ break;
+ case GLV_TPI_MARKER_TERMINATE_PROCESS:
+ break;
+ //TODO processing code for all the above cases
+ default:
+ {
+ if (packet->tracer_id >= GLV_MAX_TRACER_ID_ARRAY_SIZE || packet->tracer_id == GLV_TID_RESERVED) {
+ glv_LogError("Tracer_id from packet num packet %d invalid.\n", packet->packet_id);
+ continue;
+ }
+ replayer = replayerArray[packet->tracer_id];
+ if (replayer == NULL) {
+ glv_LogWarn("Tracer_id %d has no valid replayer.\n", packet->tracer_id);
+ continue;
+ }
+ if (packet->packet_id >= GLV_TPI_BEGIN_API_HERE)
+ {
+ // replay the API packet
+ res = replayer->Replay(packet);
+ if (res != GLV_REPLAY_SUCCESS)
+ {
+ glv_LogError("Failed to replay packet_id %d.\n",packet->packet_id);
+ }
+ } else {
+ glv_LogError("Bad packet type id=%d, index=%d.\n", packet->packet_id, packet->global_packet_index);
+ return -1;
+ }
+ }
+ }
+ }
+
+ return err;
+}
+} // namespace glv_replay
+
+using namespace glv_replay;
+
+extern "C"
+int main(int argc, char **argv)
+{
+ //bool hasSnapshot = false;
+ //bool fastReplay = false;
+ unsigned int debugLevel = 1;
+ int err;
+
+ // parse command line options
+ int opt;
+ while ((opt = getopt_long_only(argc, argv, shortOptions, longOptions, NULL)) != -1) {
+ switch (opt) {
+ case 'h':
+ usage(argv[0]);
+ return 0;
+ case 'b':
+ //fastReplay = true;
+ break;
+ case DEBUG_OPT:
+ debugLevel = atoi(optarg);
+ break;
+ default:
+ glv_LogError("unknown option %d\n", opt);
+ usage(argv[0]);
+ return 1;
+ }
+ }
+
+ // open trace file and read in header
+ glv_trace_file_header fileHeader;
+ FILE *tracefp;
+
+ if (optind < argc && strlen(argv[optind]) > 0) {
+ tracefp = fopen(argv[optind], "rb");
+ if (tracefp == NULL) {
+ glv_LogError("Cannot open trace file: '%s'\n", argv[optind]);
+ return 1;
+ }
+ }
+ else {
+ glv_LogError("No trace file specified\n");
+ usage(argv[0]);
+ return 1;
+ }
+
+ FileLike* traceFile = glv_FileLike_create_file(tracefp);
+ if (glv_FileLike_ReadRaw(traceFile, &fileHeader, sizeof(fileHeader)) == false)
+ {
+ glv_LogError("Unable to read header from file.\n");
+ GLV_DELETE(traceFile);
+ return 1;
+ }
+
+ // Make sure trace file version is supported
+ if (fileHeader.trace_file_version < GLV_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE)
+ {
+ glv_LogError("Trace file version %su is older than minimum compatible version (%su).\nYou'll need to make a new trace file, or use an older replayer.\n", fileHeader.trace_file_version, GLV_TRACE_FILE_VERSION_MINIMUM_COMPATIBLE);
+ }
+
+ // load any API specific driver libraries and init replayer objects
+ uint8_t tidApi = GLV_TID_RESERVED;
+ glv_trace_packet_replay_library* replayer[GLV_MAX_TRACER_ID_ARRAY_SIZE];
+ ReplayFactory makeReplayer;
+ Display disp(1024, 768, 0, false);
+
+ for (int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ {
+ replayer[i] = NULL;
+ }
+
+ for (int i = 0; i < fileHeader.tracer_count; i++)
+ {
+ uint8_t tracerId = fileHeader.tracer_id_array[i];
+ tidApi = tracerId;
+
+ const GLV_TRACER_REPLAYER_INFO* pReplayerInfo = &(gs_tracerReplayerInfo[tracerId]);
+
+ if (pReplayerInfo->tracerId != tracerId)
+ {
+ glv_LogError("Replayer info for TracerId (%d) failed consistency check.\n", tracerId);
+ assert(!"TracerId in GLV_TRACER_REPLAYER_INFO does not match the requested tracerId. The array needs to be corrected.");
+ }
+ else if (pReplayerInfo->needsReplayer == TRUE)
+ {
+ // Have our factory create the necessary replayer
+ replayer[tracerId] = makeReplayer.Create(tracerId);
+
+ if (replayer[tracerId] == NULL)
+ {
+ // replayer failed to be created
+ return err;
+ }
+
+ // Initalize the replayer
+ err = replayer[tracerId]->Initialize(&disp, debugLevel);
+ if (err) {
+ glv_LogError("Couldn't Initialize replayer for TracerId %d.\n", tracerId);
+ return err;
+ }
+ }
+ }
+
+ if (tidApi == GLV_TID_RESERVED) {
+ glv_LogError("No API specified in tracefile for replaying.\n");
+ return -1;
+ }
+
+ // process snapshot if present
+ if (fileHeader.contains_state_snapshot) {
+ //TODO
+ }
+
+ // main loop
+ Sequencer sequencer(traceFile);
+ err = glv_replay::main_loop(sequencer, replayer);
+
+ for (int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ {
+ if (replayer[i] != NULL)
+ {
+ replayer[i]->Deinitialize();
+ makeReplayer.Destroy(&replayer[i]);
+ }
+ }
+ return err;
+}
diff --git a/tools/glave/src/glvreplay/glvreplay_seq.cpp b/tools/glave/src/glvreplay/glvreplay_seq.cpp
new file mode 100644
index 0000000..8a943f0
--- /dev/null
+++ b/tools/glave/src/glvreplay/glvreplay_seq.cpp
@@ -0,0 +1,54 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glvreplay_seq.h"
+
+extern "C" {
+#include "glv_trace_packet_utils.h"
+}
+
+namespace glv_replay {
+
+glv_trace_packet_header * Sequencer::get_next_packet()
+{
+ glv_free(m_lastPacket);
+ if (!m_pFile)
+ return (NULL);
+ m_lastPacket = glv_read_trace_packet(m_pFile);
+ return(m_lastPacket);
+}
+
+void Sequencer::get_bookmark(seqBookmark &bookmark) {
+ bookmark.file_offset = m_bookmark.file_offset;
+ bookmark.next_index = m_bookmark.next_index;
+}
+
+
+void Sequencer::set_bookmark(const seqBookmark &bookmark) {
+ m_bookmark.file_offset = bookmark.file_offset;
+ m_bookmark.next_index = bookmark.next_index;
+
+}
+
+} /* namespace glv_replay */
diff --git a/tools/glave/src/glvreplay/glvreplay_seq.h b/tools/glave/src/glvreplay/glvreplay_seq.h
new file mode 100644
index 0000000..2e39379
--- /dev/null
+++ b/tools/glave/src/glvreplay/glvreplay_seq.h
@@ -0,0 +1,75 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+extern "C" {
+#include "glv_filelike.h"
+#include "glv_trace_packet_identifiers.h"
+}
+
+/* Class to handle fetching and sequencing packets from a tracefile.
+ * Contains no knowledge of type of tracer needed to process packet.
+ * Requires low level file/stream reading/seeking support. */
+namespace glv_replay {
+
+
+struct seqBookmark
+{
+ unsigned int file_offset;
+ uint64_t next_index;
+};
+
+
+// replay Sequencer interface
+ class AbstractSequencer
+ {
+ public:
+ virtual ~AbstractSequencer() {}
+ virtual glv_trace_packet_header *get_next_packet() = 0;
+ virtual void get_bookmark(seqBookmark &bookmark) = 0;
+ virtual void set_bookmark(const seqBookmark &bookmark) = 0;
+ };
+
+class Sequencer: public AbstractSequencer
+{
+
+public:
+ Sequencer(FileLike* pFile) : m_lastPacket(NULL), m_pFile(pFile) {}
+ ~Sequencer() { delete m_lastPacket;}
+
+ glv_trace_packet_header *get_next_packet();
+ void get_bookmark(seqBookmark &bookmark);
+ void set_bookmark(const seqBookmark &bookmark);
+
+private:
+ glv_trace_packet_header *m_lastPacket;
+ seqBookmark m_bookmark;
+ FileLike *m_pFile;
+
+};
+
+} /* namespace glv_replay */
+
+
diff --git a/tools/glave/src/glvreplay/glvreplay_window.h b/tools/glave/src/glvreplay/glvreplay_window.h
new file mode 100644
index 0000000..a8e7049
--- /dev/null
+++ b/tools/glave/src/glvreplay/glvreplay_window.h
@@ -0,0 +1,136 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Lunarg, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+extern "C"{
+#include "glv_platform.h"
+}
+
+#if defined(WIN32)
+typedef HWND glv_window_handle;
+#else
+typedef void* glv_window_handle;
+#endif
+
+/* classes to abstract the display and initialization of rendering API for presenting
+ * framebuffers for display into a window on the screen or else fullscreen.
+ * Uses Bridge design pattern.
+ */
+namespace glv_replay {
+
+class DisplayImp {
+public:
+ virtual ~DisplayImp() {}
+ virtual int init(const unsigned int gpu_idx) = 0;
+ virtual int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height) = 0;
+ virtual int create_window(const unsigned int width, const unsigned int height) = 0;
+ virtual void process_event() = 0;
+};
+
+class Display {
+public:
+ Display()
+ : m_imp(NULL),
+ m_width(0),
+ m_height(0),
+ m_gpu(0),
+ m_fullscreen(false),
+ m_hWindow(0)
+ {
+
+ }
+
+ Display(const unsigned int width, const unsigned int height, const unsigned int gpu, const bool fullscreen) :
+ m_imp(NULL),
+ m_width(width),
+ m_height(height),
+ m_gpu(gpu),
+ m_fullscreen(fullscreen),
+ m_hWindow(0)
+ {
+ }
+
+ Display(glv_window_handle hWindow, unsigned int width, unsigned int height) :
+ m_imp(NULL),
+ m_width(width),
+ m_height(height),
+ m_gpu(0),
+ m_fullscreen(false),
+ m_hWindow(hWindow)
+ {
+ }
+
+ virtual ~Display()
+ {
+ }
+
+ void set_implementation(DisplayImp & disp)
+ {
+ m_imp = & disp;
+ }
+ void set_implementation(DisplayImp * disp)
+ {
+ m_imp = disp;
+ }
+ int init()
+ {
+ if (m_imp)
+ return m_imp->init(m_gpu);
+ else
+ return -1;
+ }
+ void process_event()
+ {
+ if(m_imp)
+ m_imp->process_event();
+ }
+ unsigned int get_gpu()
+ {
+ return m_gpu;
+ }
+ unsigned int get_width()
+ {
+ return m_width;
+ }
+ unsigned int get_height()
+ {
+ return m_height;
+ }
+
+ glv_window_handle get_window_handle()
+ {
+ return m_hWindow;
+ }
+
+private:
+ DisplayImp *m_imp;
+ unsigned int m_width;
+ unsigned int m_height;
+ unsigned int m_gpu;
+ bool m_fullscreen;
+ glv_window_handle m_hWindow;
+};
+
+} // namespace glv_replay
diff --git a/tools/glave/src/glvtrace/CMakeLists.txt b/tools/glave/src/glvtrace/CMakeLists.txt
new file mode 100644
index 0000000..5cba273
--- /dev/null
+++ b/tools/glave/src/glvtrace/CMakeLists.txt
@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 2.8)
+project(glvtrace)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+set(SRC_LIST
+ ${SRC_LIST}
+ glvtrace.cpp
+ glvtrace_process.h
+ glvtrace_process.cpp
+)
+
+include_directories(
+ ${SRC_DIR}
+ ${SRC_DIR}/glvcommon
+ ${SRC_DIR}/glvtrace
+)
+
+add_executable(${PROJECT_NAME} ${SRC_LIST})
+
+
+target_link_libraries(${PROJECT_NAME}
+ glvcommon
+)
+
+build_options_finalize()
diff --git a/tools/glave/src/glvtrace/glvtrace.cpp b/tools/glave/src/glvtrace/glvtrace.cpp
new file mode 100644
index 0000000..827a729
--- /dev/null
+++ b/tools/glave/src/glvtrace/glvtrace.cpp
@@ -0,0 +1,317 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#include "glvtrace.h"
+
+#include "glvtrace_process.h"
+
+extern "C" {
+#include "glv_common.h"
+#include "glv_filelike.h"
+#include "glv_interconnect.h"
+#include "glv_trace_packet_identifiers.h"
+#include "glv_trace_packet_utils.h"
+}
+
+glvtrace_settings g_settings;
+glvtrace_settings g_default_settings;
+
+glv_SettingInfo g_settings_info[] =
+{
+ // common command options
+ { "p", "program", GLV_SETTING_STRING, &g_settings.program, &g_default_settings.program, TRUE, "The program to trace."},
+ { "a", "arguments", GLV_SETTING_STRING, &g_settings.arguments, &g_default_settings.arguments, TRUE, "Cmd-line arguments to pass to trace program."},
+ { "w", "working_dir", GLV_SETTING_STRING, &g_settings.working_dir, &g_default_settings.working_dir, TRUE, "The program's working directory."},
+ { "o", "output_trace", GLV_SETTING_STRING, &g_settings.output_trace, &g_default_settings.output_trace, TRUE, "Path to the generated output trace file."},
+ { "l0", "trace_library0", GLV_SETTING_STRING, &g_settings.trace_library[0], NULL, TRUE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l1", "trace_library1", GLV_SETTING_STRING, &g_settings.trace_library[1], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l2", "trace_library2", GLV_SETTING_STRING, &g_settings.trace_library[2], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l3", "trace_library3", GLV_SETTING_STRING, &g_settings.trace_library[3], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l4", "trace_library4", GLV_SETTING_STRING, &g_settings.trace_library[4], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l5", "trace_library5", GLV_SETTING_STRING, &g_settings.trace_library[5], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l6", "trace_library6", GLV_SETTING_STRING, &g_settings.trace_library[6], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l7", "trace_library7", GLV_SETTING_STRING, &g_settings.trace_library[7], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l8", "trace_library8", GLV_SETTING_STRING, &g_settings.trace_library[8], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l9", "trace_library9", GLV_SETTING_STRING, &g_settings.trace_library[9], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l10", "trace_library10", GLV_SETTING_STRING, &g_settings.trace_library[10], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l11", "trace_library11", GLV_SETTING_STRING, &g_settings.trace_library[11], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l12", "trace_library12", GLV_SETTING_STRING, &g_settings.trace_library[12], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l13", "trace_library13", GLV_SETTING_STRING, &g_settings.trace_library[13], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l14", "trace_library14", GLV_SETTING_STRING, &g_settings.trace_library[14], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "l15", "trace_library15", GLV_SETTING_STRING, &g_settings.trace_library[15], NULL, FALSE, "Path to the dynamic tracer library to be injected, may use [0-15]."},
+ { "tlf", "trace_log_file", GLV_SETTING_STRING, &g_settings.tracelogfile, &g_default_settings.tracelogfile, TRUE, "Log file to write into from trace application."},
+ { "ptm", "print_trace_messages", GLV_SETTING_BOOL, &g_settings.print_trace_messages, &g_default_settings.print_trace_messages, TRUE, "Print trace messages to glvtrace console."},
+
+ //{ "s", "pause", GLV_SETTING_BOOL, &g_settings.pause, &g_default_settings.pause, TRUE, "Wait for a key at startup (so a debugger can be attached)" },
+ //{ "q", "quiet", GLV_SETTING_BOOL, &g_settings.quiet, &g_default_settings.quiet, TRUE, "Disable warning, verbose, and debug output" },
+ //{ "v", "verbose", GLV_SETTING_BOOL, &g_settings.verbose, &g_default_settings.verbose, TRUE, "Enable verbose output" },
+ //{ "d", "debug", GLV_SETTING_BOOL, &g_settings.debug, &g_default_settings.debug, TRUE, "Enable verbose debug information" },
+};
+
+// ------------------------------------------------------------------------------------------------
+#if defined(WIN32)
+void MessageLoop()
+{
+ MSG msg = { 0 };
+ bool quit = false;
+ while (!quit)
+ {
+ if (GetMessage(&msg, NULL, 0, 0) == FALSE)
+ {
+ quit = true;
+ }
+ else
+ {
+ quit = (msg.message == GLV_WM_COMPLETE);
+ }
+ }
+}
+#endif
+
+// returns the number of tracers that need to be injected
+int PrepareTracers(glvtrace_settings* pSettings, glv_process_capture_trace_thread_info** ppTracerInfo)
+{
+ // determine number of tracers to load and inject
+ unsigned int num_tracers = 0;
+ for (unsigned int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ {
+ if (g_settings.trace_library[i] != NULL)
+ {
+ ++num_tracers;
+ }
+ }
+
+ assert(ppTracerInfo != NULL && *ppTracerInfo == NULL);
+ *ppTracerInfo = GLV_NEW_ARRAY(glv_process_capture_trace_thread_info, num_tracers);
+ memset(*ppTracerInfo, 0, sizeof(glv_process_capture_trace_thread_info) * num_tracers);
+
+ // consolidate the list, but also reverse the order so that the entrypoints should be hooked in the expected order
+ unsigned int tmpTracerIndex = num_tracers;
+ for (unsigned int i = 0; i < GLV_MAX_TRACER_ID_ARRAY_SIZE; i++)
+ {
+ if (g_settings.trace_library[i] != NULL)
+ {
+ void* hLibrary = glv_platform_open_library(g_settings.trace_library[i]);
+ if (hLibrary == NULL)
+ {
+ glv_LogError("Failed to load tracer: %s\n", g_settings.trace_library[i]);
+ }
+ else
+ {
+ funcptr_GLV_GetTracerId GLV_GetTracerId = NULL;
+ GLV_GetTracerId = (funcptr_GLV_GetTracerId)glv_platform_get_library_entrypoint(hLibrary, "GLV_GetTracerId");
+
+ if (GLV_GetTracerId != NULL)
+ {
+ --tmpTracerIndex;
+ (*ppTracerInfo)[tmpTracerIndex].tracerPath = g_settings.trace_library[i];
+ (*ppTracerInfo)[tmpTracerIndex].tracerId = GLV_GetTracerId();
+ }
+ else
+ {
+ glv_LogError("Missing entrypoint GLV_GetTracerId() from %s\n", g_settings.trace_library[i]);
+ }
+ glv_platform_close_library(hLibrary);
+ }
+ }
+ }
+
+ if (tmpTracerIndex > 0)
+ {
+ glv_LogError("One or more tracers could not be loaded. Please correct the issue and try again.\n");
+ }
+
+ return num_tracers;
+}
+
+bool InjectTracersIntoProcess(glv_process_info* pInfo)
+{
+ bool bRecordingThreadsCreated = true;
+ for (unsigned int i = 0; i < pInfo->tracerCount; i++)
+ {
+ // inject tracers
+ if (glv_platform_remote_load_library(pInfo->hProcess, pInfo->pCaptureThreads[i].tracerPath, &pInfo->pCaptureThreads[i].tracingThread, &pInfo->processLDPreload))
+ {
+ // prepare data for capture threads
+ pInfo->pCaptureThreads[i].pProcessInfo = pInfo;
+ pInfo->pCaptureThreads[i].recordingThread = GLV_NULL_THREAD;
+
+ // create thread to record trace packets from the tracer
+ pInfo->pCaptureThreads[i].recordingThread = glv_platform_create_thread(Process_RunRecordTraceThread, &(pInfo->pCaptureThreads[i]));
+ if (pInfo->pCaptureThreads[i].recordingThread == GLV_NULL_THREAD)
+ {
+ glv_LogError("Failed to create trace recording thread.\n");
+ bRecordingThreadsCreated = false;
+ }
+
+#if defined(WIN32)
+ // wait for the hooking / tracing thread to complete now that its recording thread is listening
+ if (WaitForSingleObject(pInfo->pCaptureThreads[i].tracingThread, INFINITE) != WAIT_OBJECT_0)
+ {
+ glv_LogError("Injected tracer's thread did not return successfully.\n");
+ bRecordingThreadsCreated = false;
+ }
+#endif
+ }
+ else
+ {
+ // failed to inject a DLL
+ bRecordingThreadsCreated = false;
+ break;
+ }
+ }
+ return bRecordingThreadsCreated;
+}
+
+// ------------------------------------------------------------------------------------------------
+int main(int argc, char* argv[])
+{
+ unsigned int num_settings = sizeof(g_settings_info) / sizeof(g_settings_info[0]);
+
+ memset(&g_settings, 0, sizeof(glvtrace_settings));
+
+ // setup defaults
+ memset(&g_default_settings, 0, sizeof(glvtrace_settings));
+ g_default_settings.output_trace = glv_allocate_and_copy("glvtrace_out.trace");
+ g_default_settings.tracelogfile = glv_allocate_and_copy("glv_log.txt");
+ g_default_settings.print_trace_messages = FALSE;
+
+ if (glv_SettingInfo_init(g_settings_info, num_settings, "glvtrace_settings.txt", argc, argv, &g_settings.arguments) != 0)
+ {
+ // invalid cmd-line parameters
+ glv_SettingInfo_delete(g_settings_info, num_settings);
+ glv_free(g_default_settings.output_trace);
+ glv_free(g_default_settings.tracelogfile);
+ return -1;
+ }
+ else
+ {
+ BOOL validArgs = TRUE;
+ if (g_settings.program == NULL || strlen(g_settings.program) == 0)
+ {
+ glv_LogError("Missing parameter: Don't know the program to trace.\n");
+ validArgs = FALSE;
+ }
+ else
+ {
+ if (g_settings.working_dir == NULL || strlen(g_settings.working_dir) == 0)
+ {
+ CHAR buf[4096];
+ glv_LogWarn("Missing parameter: No working directory specified, assuming executable's path.\n");
+ glv_platform_full_path(g_settings.program, 4096, buf);
+ g_settings.working_dir = glv_platform_extract_path(buf);
+ }
+ }
+
+ if (g_settings.arguments != NULL && strlen(g_settings.arguments) > 0)
+ {
+ glv_LogInfo("Args to be passed to child process: '%s'\n", g_settings.arguments);
+ }
+
+ if (validArgs == FALSE)
+ {
+ glv_SettingInfo_print_all(g_settings_info, num_settings);
+ return -1;
+ }
+ }
+
+ if (g_settings.tracelogfile != NULL && strlen(g_settings.tracelogfile) > 0)
+ {
+ glv_tracelog_set_log_file(glv_FileLike_create_file(fopen(g_settings.tracelogfile, "w+")));
+ }
+
+ {
+ // Create and start the process.
+
+ BOOL procStarted = TRUE;
+ glv_process_info procInfo;
+ memset(&procInfo, 0, sizeof(glv_process_info));
+ procInfo.exeName = glv_allocate_and_copy(g_settings.program);
+ procInfo.processArgs = glv_allocate_and_copy(g_settings.arguments);
+ procInfo.workingDirectory = glv_allocate_and_copy(g_settings.working_dir);
+ procInfo.traceFilename = glv_allocate_and_copy(g_settings.output_trace);
+ procInfo.parentThreadId = glv_platform_get_thread_id();
+
+ // setup tracers
+ procInfo.tracerCount = PrepareTracers(&g_settings, &procInfo.pCaptureThreads);
+
+#if defined(WIN32)
+ // call CreateProcess to launch the application
+ procStarted = glv_process_spawn(&procInfo);
+#endif
+
+ if (procStarted == TRUE && procInfo.tracerCount > 0)
+ {
+ if (InjectTracersIntoProcess(&procInfo) == FALSE)
+ {
+ glv_LogError("Failed to setup tracer communication threads.\n");
+ }
+ else
+ {
+ // create trace file before injecting tracers
+ procInfo.pTraceFile = glv_write_trace_file_header(&procInfo);
+ }
+ }
+
+#if defined(PLATFORM_LINUX)
+ // in linux we want to spawn the process AFTER setting up LD_PRELOAD (which happens in the loop above)
+ procStarted = glv_process_spawn(&procInfo);
+#endif
+
+ if (procStarted == FALSE)
+ {
+ glv_LogError("Failed to setup remote process.\n");
+ }
+ else
+ {
+ // create watchdog thread to monitor existence of remote process
+ procInfo.watchdogThread = glv_platform_create_thread(Process_RunWatchdogThread, &procInfo);
+
+#if defined(PLATFORM_LINUX)
+ // Sync wait for local threads and remote process to complete.
+ for (unsigned int i = 0; i < procInfo.tracerCount; i++)
+ {
+ glv_platform_sync_wait_for_thread(&(procInfo.pCaptureThreads[i].recordingThread));
+ }
+
+ glv_platform_sync_wait_for_thread(&procInfo.watchdogThread);
+#else
+ glv_platform_resume_thread(&procInfo.hThread);
+
+ // Now into the main message loop, listen for hotkeys to send over.
+ MessageLoop();
+#endif
+ }
+
+ glv_process_info_delete(&procInfo);
+ }
+
+ glv_SettingInfo_delete(g_settings_info, num_settings);
+ glv_free(g_default_settings.output_trace);
+ glv_free(g_default_settings.tracelogfile);
+ glv_tracelog_delete_log_file();
+
+ return 0;
+}
+
diff --git a/tools/glave/src/glvtrace/glvtrace.h b/tools/glave/src/glvtrace/glvtrace.h
new file mode 100644
index 0000000..3fbaf98
--- /dev/null
+++ b/tools/glave/src/glvtrace/glvtrace.h
@@ -0,0 +1,50 @@
+/**************************************************************************
+ *
+ * Copyright 2014 Valve Software
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ **************************************************************************/
+#pragma once
+
+extern "C" {
+#include "glv_settings.h"
+}
+
+
+#if defined(WIN32)
+#define GLV_WM_COMPLETE (WM_USER + 0)
+#endif
+
+//----------------------------------------------------------------------------------------------------------------------
+// globals
+//----------------------------------------------------------------------------------------------------------------------
+typedef struct glvtrace_settings
+{
+ char* program;
+ char* arguments;
+ char* working_dir;
+ char* output_trace;
+ char* trace_library[16];
+ char* tracelogfile;
+ BOOL print_trace_messages;
+} glvtrace_settings;
+
+extern glvtrace_settings g_settings;
diff --git a/tools/glave/src/glvtrace/glvtrace_process.cpp b/tools/glave/src/glvtrace/glvtrace_process.cpp
new file mode 100644
index 0000000..604a90f
--- /dev/null
+++ b/tools/glave/src/glvtrace/glvtrace_process.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 <string>
+#include "glvtrace_process.h"
+#include "glvtrace.h"
+
+#if defined(PLATFORM_LINUX)
+#include <sys/prctl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#endif
+
+extern "C" {
+#include "glv_filelike.h"
+#include "glv_interconnect.h"
+#include "glv_trace_packet_utils.h"
+}
+
+const unsigned long kWatchDogPollTime = 250;
+
+#if defined(WIN32)
+void SafeCloseHandle(HANDLE& _handle)
+{
+ if (_handle) {
+ CloseHandle(_handle);
+ _handle = NULL;
+ }
+}
+#endif
+
+// ------------------------------------------------------------------------------------------------
+GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunWatchdogThread(LPVOID _procInfoPtr)
+{
+ glv_process_info* pProcInfo = (glv_process_info*)_procInfoPtr;
+
+#if defined(WIN32)
+
+ while (WaitForSingleObject(pProcInfo->hProcess, kWatchDogPollTime) == WAIT_TIMEOUT)
+ {
+ if (pProcInfo->serverRequestsTermination)
+ {
+ glv_LogInfo("GLVTrace has requested exit.\n");
+ return 0;
+ }
+ }
+
+ glv_LogInfo("Child Process has terminated.\n");
+
+ PostThreadMessage(pProcInfo->parentThreadId, GLV_WM_COMPLETE, 0, 0);
+ pProcInfo->serverRequestsTermination = TRUE;
+
+#elif defined(PLATFORM_LINUX)
+ int status = 0;
+ int options = 0;
+ while (waitpid(pProcInfo->processId, &status, options) != -1)
+ {
+ if (WIFEXITED(status))
+ {
+ glv_LogInfo("Child process exited\n");
+ break;
+ }
+ else if (WCOREDUMP(status))
+ {
+ glv_LogInfo("Child process crashed\n");
+ break;
+ }
+ else if (WIFSIGNALED(status))
+ glv_LogInfo("Child process was signaled\n");
+ else if (WIFSTOPPED(status))
+ glv_LogInfo("Child process was stopped\n");
+ else if (WIFCONTINUED(status))
+ glv_LogInfo("Child process was continued\n");
+ }
+#endif
+ return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunRecordTraceThread(LPVOID _threadInfo)
+{
+ glv_process_capture_trace_thread_info* pInfo = (glv_process_capture_trace_thread_info*)_threadInfo;
+
+ MessageStream* pMessageStream = glv_MessageStream_create(FALSE, "127.0.0.1", GLV_BASE_PORT + pInfo->tracerId);
+
+ if (pMessageStream == NULL)
+ {
+ glv_LogError("Thread_CaptureTrace() cannot create message stream\n");
+ return 1;
+ }
+
+ FileLike* fileLikeSocket = glv_FileLike_create_msg(pMessageStream);
+ unsigned int total_packet_count = 0;
+ glv_trace_packet_header* pHeader = NULL;
+ size_t bytes_written;
+
+ while (pInfo->pProcessInfo->serverRequestsTermination == FALSE)
+ {
+ // get a packet
+ //glv_LogDebug("Waiting for a packet...");
+
+ // read entire packet in
+ pHeader = glv_read_trace_packet(fileLikeSocket);
+ ++total_packet_count;
+ if (pHeader == NULL)
+ {
+ if (pMessageStream->mErrorNum == WSAECONNRESET)
+ {
+ glv_LogError("Network Connection Reset\n");
+ }
+ else
+ {
+ glv_LogError("Network Connection Failed\n");
+ }
+ break;
+ }
+
+ //glv_LogDebug("Received packet id: %hu\n", pHeader->packet_id);
+
+ if (pHeader->pBody == (uintptr_t) NULL)
+ {
+ glv_LogWarn("Received empty packet body for id: %hu\n", pHeader->packet_id);
+ }
+ else
+ {
+ // handle special case packets
+ if (pHeader->packet_id == GLV_TPI_MESSAGE)
+ {
+ if (g_settings.print_trace_messages == TRUE)
+ {
+ glv_trace_packet_message* pPacket = glv_interpret_body_as_trace_packet_message(pHeader);
+ glv_PrintTraceMessage(pPacket->type, pPacket->message);
+ printf("packet index: %lu\n", pHeader->global_packet_index);
+ glv_finalize_buffer_address(pHeader, (void **) &(pPacket->message));
+ }
+ }
+
+ if (pHeader->packet_id == GLV_TPI_MARKER_TERMINATE_PROCESS)
+ {
+ pInfo->pProcessInfo->serverRequestsTermination = true;
+ glv_delete_trace_packet(&pHeader);
+ printf("Thread_CaptureTrace is exiting\n");
+ break;
+ }
+
+ if (pInfo->pProcessInfo->pTraceFile != NULL)
+ {
+ glv_enter_critical_section(&pInfo->pProcessInfo->traceFileCriticalSection);
+ bytes_written = fwrite(pHeader, 1, (size_t)pHeader->size, pInfo->pProcessInfo->pTraceFile);
+ fflush(pInfo->pProcessInfo->pTraceFile);
+ glv_leave_critical_section(&pInfo->pProcessInfo->traceFileCriticalSection);
+ if (bytes_written != pHeader->size)
+ {
+ glv_LogError("Failed to write the packet for packet_id = %hu\n", pHeader->packet_id);
+ }
+ }
+ }
+
+ // clean up
+ glv_delete_trace_packet(&pHeader);
+ }
+
+ GLV_DELETE(fileLikeSocket);
+ glv_MessageStream_destroy(&pMessageStream);
+
+ return 0;
+}
diff --git a/tools/glave/src/glvtrace/glvtrace_process.h b/tools/glave/src/glvtrace/glvtrace_process.h
new file mode 100644
index 0000000..2446dec
--- /dev/null
+++ b/tools/glave/src/glvtrace/glvtrace_process.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2014, Valve Software. 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.
+ * * Neither the name of NVIDIA CORPORATION nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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.
+ */
+
+#pragma once
+
+extern "C" {
+#include "glv_common.h"
+#include "glv_process.h"
+#include "glv_interconnect.h"
+}
+
+GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunRecordTraceThread(LPVOID);
+
+GLV_THREAD_ROUTINE_RETURN_TYPE Process_RunWatchdogThread(LPVOID);
diff --git a/tools/glave/src/thirdparty/getopt/CMakeLists.txt b/tools/glave/src/thirdparty/getopt/CMakeLists.txt
new file mode 100644
index 0000000..5e66aca
--- /dev/null
+++ b/tools/glave/src/thirdparty/getopt/CMakeLists.txt
@@ -0,0 +1,12 @@
+include_directories (${CMAKE_CURRENT_SOURCE_DIR})
+
+include("${SRC_DIR}/build_options.cmake")
+
+set(SRC_LIST
+ getopt_long.c
+ getopt.h
+)
+add_library (getopt_bundled STATIC EXCLUDE_FROM_ALL ${SRC_LIST})
+
+
+build_options_finalize()
diff --git a/tools/glave/src/thirdparty/getopt/LICENSE b/tools/glave/src/thirdparty/getopt/LICENSE
new file mode 100644
index 0000000..1a9141b
--- /dev/null
+++ b/tools/glave/src/thirdparty/getopt/LICENSE
@@ -0,0 +1,45 @@
+Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Sponsored in part by the Defense Advanced Research Projects
+Agency (DARPA) and Air Force Research Laboratory, Air Force
+Materiel Command, USAF, under agreement number F39502-99-1-0512.
+
+
+Copyright (c) 2000 The NetBSD Foundation, Inc.
+All rights reserved.
+
+This code is derived from software contributed to The NetBSD Foundation
+by Dieter Baron and Thomas Klausner.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
diff --git a/tools/glave/src/thirdparty/getopt/getopt.h b/tools/glave/src/thirdparty/getopt/getopt.h
new file mode 100644
index 0000000..117608f
--- /dev/null
+++ b/tools/glave/src/thirdparty/getopt/getopt.h
@@ -0,0 +1,82 @@
+/* $OpenBSD: getopt.h,v 1.2 2008/06/26 05:42:04 ray Exp $ */
+/* $NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $ */
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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 _GETOPT_H_
+#define _GETOPT_H_
+
+/*
+ * GNU-like getopt_long() and 4.4BSD getsubopt()/optreset extensions
+ */
+#define no_argument 0
+#define required_argument 1
+#define optional_argument 2
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct option {
+ /* name of long option */
+ const char *name;
+ /*
+ * one of no_argument, required_argument, and optional_argument:
+ * whether option takes an argument
+ */
+ int has_arg;
+ /* if not NULL, set *flag to val when option found */
+ int *flag;
+ /* if flag not NULL, value to set *flag to; else return value */
+ int val;
+};
+
+int getopt_long(int, char * const *, const char *,
+ const struct option *, int *);
+int getopt_long_only(int, char * const *, const char *,
+ const struct option *, int *);
+#ifndef _GETOPT_DEFINED_
+#define _GETOPT_DEFINED_
+int getopt(int, char * const *, const char *);
+int getsubopt(char **, char * const *, char **);
+
+extern char *optarg; /* getopt(3) external variables */
+extern int opterr;
+extern int optind;
+extern int optopt;
+extern int optreset;
+extern char *suboptarg; /* getsubopt(3) external variable */
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_GETOPT_H_ */
diff --git a/tools/glave/src/thirdparty/getopt/getopt_long.c b/tools/glave/src/thirdparty/getopt/getopt_long.c
new file mode 100644
index 0000000..81268b8
--- /dev/null
+++ b/tools/glave/src/thirdparty/getopt/getopt_long.c
@@ -0,0 +1,511 @@
+/* $OpenBSD: getopt_long.c,v 1.24 2010/07/22 19:31:53 blambert Exp $ */
+/* $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $ */
+
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int opterr = 1; /* if error message should be printed */
+int optind = 1; /* index into parent argv vector */
+int optopt = '?'; /* character checked for validity */
+int optreset; /* reset getopt */
+char *optarg; /* argument associated with option */
+
+#define PRINT_ERROR ((opterr) && (*options != ':'))
+
+#define FLAG_PERMUTE 0x01 /* permute non-options to the end of argv */
+#define FLAG_ALLARGS 0x02 /* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY 0x04 /* operate as getopt_long_only */
+
+/* return values */
+#define BADCH (int)'?'
+#define BADARG ((*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
+
+#define EMSG ""
+
+static int getopt_internal(int, char * const *, const char *,
+ const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+ const struct option *, int *, int);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1; /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(int a, int b)
+{
+ int c;
+
+ c = a % b;
+ while (c != 0) {
+ a = b;
+ b = c;
+ c = a % b;
+ }
+
+ return (b);
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+ char * const *nargv)
+{
+ int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+ char *swap;
+
+ /*
+ * compute lengths of blocks and number and size of cycles
+ */
+ nnonopts = panonopt_end - panonopt_start;
+ nopts = opt_end - panonopt_end;
+ ncycle = gcd(nnonopts, nopts);
+ cyclelen = (opt_end - panonopt_start) / ncycle;
+
+ for (i = 0; i < ncycle; i++) {
+ cstart = panonopt_end+i;
+ pos = cstart;
+ for (j = 0; j < cyclelen; j++) {
+ if (pos >= panonopt_end)
+ pos -= nnonopts;
+ else
+ pos += nopts;
+ swap = nargv[pos];
+ /* LINTED const cast */
+ ((char **) nargv)[pos] = nargv[cstart];
+ /* LINTED const cast */
+ ((char **)nargv)[cstart] = swap;
+ }
+ }
+}
+
+/*
+ * parse_long_options --
+ * Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+ const struct option *long_options, int *idx, int short_too)
+{
+ char *current_argv, *has_equal;
+ size_t current_argv_len;
+ int i, match;
+
+ current_argv = place;
+ match = -1;
+
+ optind++;
+
+ if ((has_equal = strchr(current_argv, '=')) != NULL) {
+ /* argument found (--option=arg) */
+ current_argv_len = has_equal - current_argv;
+ has_equal++;
+ } else
+ current_argv_len = strlen(current_argv);
+
+ for (i = 0; long_options[i].name; i++) {
+ /* find matching long option */
+ if (strncmp(current_argv, long_options[i].name,
+ current_argv_len))
+ continue;
+
+ if (strlen(long_options[i].name) == current_argv_len) {
+ /* exact match */
+ match = i;
+ break;
+ }
+ /*
+ * If this is a known short option, don't allow
+ * a partial match of a single character.
+ */
+ if (short_too && current_argv_len == 1)
+ continue;
+
+ if (match == -1) /* partial match */
+ match = i;
+ else {
+ /* ambiguous abbreviation */
+ if (PRINT_ERROR)
+ fprintf(stderr, ambig, (int)current_argv_len,
+ current_argv);
+ optopt = 0;
+ return (BADCH);
+ }
+ }
+ if (match != -1) { /* option found */
+ if (long_options[match].has_arg == no_argument
+ && has_equal) {
+ if (PRINT_ERROR)
+ fprintf(stderr, noarg, (int)current_argv_len,
+ current_argv);
+ /*
+ * XXX: GNU sets optopt to val regardless of flag
+ */
+ if (long_options[match].flag == NULL)
+ optopt = long_options[match].val;
+ else
+ optopt = 0;
+ return (BADARG);
+ }
+ if (long_options[match].has_arg == required_argument ||
+ long_options[match].has_arg == optional_argument) {
+ if (has_equal)
+ optarg = has_equal;
+ else if (long_options[match].has_arg ==
+ required_argument) {
+ /*
+ * optional argument doesn't use next nargv
+ */
+ optarg = nargv[optind++];
+ }
+ }
+ if ((long_options[match].has_arg == required_argument)
+ && (optarg == NULL)) {
+ /*
+ * Missing argument; leading ':' indicates no error
+ * should be generated.
+ */
+ if (PRINT_ERROR)
+ fprintf(stderr, recargstring,
+ current_argv);
+ /*
+ * XXX: GNU sets optopt to val regardless of flag
+ */
+ if (long_options[match].flag == NULL)
+ optopt = long_options[match].val;
+ else
+ optopt = 0;
+ --optind;
+ return (BADARG);
+ }
+ } else { /* unknown option */
+ if (short_too) {
+ --optind;
+ return (-1);
+ }
+ if (PRINT_ERROR)
+ fprintf(stderr, illoptstring, current_argv);
+ optopt = 0;
+ return (BADCH);
+ }
+ if (idx)
+ *idx = match;
+ if (long_options[match].flag) {
+ *long_options[match].flag = long_options[match].val;
+ return (0);
+ } else
+ return (long_options[match].val);
+}
+
+/*
+ * getopt_internal --
+ * Parse argc/argv argument vector. Called by user level routines.
+ */
+static int
+getopt_internal(int nargc, char * const *nargv, const char *options,
+ const struct option *long_options, int *idx, int flags)
+{
+ char *oli; /* option letter list index */
+ int optchar, short_too;
+ static int posixly_correct = -1;
+
+ if (options == NULL)
+ return (-1);
+
+ /*
+ * Disable GNU extensions if POSIXLY_CORRECT is set or options
+ * string begins with a '+'.
+ */
+ if (posixly_correct == -1)
+ posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+ if (posixly_correct || *options == '+')
+ flags &= ~FLAG_PERMUTE;
+ else if (*options == '-')
+ flags |= FLAG_ALLARGS;
+ if (*options == '+' || *options == '-')
+ options++;
+
+ /*
+ * XXX Some GNU programs (like cvs) set optind to 0 instead of
+ * XXX using optreset. Work around this braindamage.
+ */
+ if (optind == 0)
+ optind = optreset = 1;
+
+ optarg = NULL;
+ if (optreset)
+ nonopt_start = nonopt_end = -1;
+start:
+ if (optreset || !*place) { /* update scanning pointer */
+ optreset = 0;
+ if (optind >= nargc) { /* end of argument vector */
+ place = EMSG;
+ if (nonopt_end != -1) {
+ /* do permutation, if we have to */
+ permute_args(nonopt_start, nonopt_end,
+ optind, nargv);
+ optind -= nonopt_end - nonopt_start;
+ }
+ else if (nonopt_start != -1) {
+ /*
+ * If we skipped non-options, set optind
+ * to the first of them.
+ */
+ optind = nonopt_start;
+ }
+ nonopt_start = nonopt_end = -1;
+ return (-1);
+ }
+ if (*(place = nargv[optind]) != '-' ||
+ (place[1] == '\0' && strchr(options, '-') == NULL)) {
+ place = EMSG; /* found non-option */
+ if (flags & FLAG_ALLARGS) {
+ /*
+ * GNU extension:
+ * return non-option as argument to option 1
+ */
+ optarg = nargv[optind++];
+ return (INORDER);
+ }
+ if (!(flags & FLAG_PERMUTE)) {
+ /*
+ * If no permutation wanted, stop parsing
+ * at first non-option.
+ */
+ return (-1);
+ }
+ /* do permutation */
+ if (nonopt_start == -1)
+ nonopt_start = optind;
+ else if (nonopt_end != -1) {
+ permute_args(nonopt_start, nonopt_end,
+ optind, nargv);
+ nonopt_start = optind -
+ (nonopt_end - nonopt_start);
+ nonopt_end = -1;
+ }
+ optind++;
+ /* process next argument */
+ goto start;
+ }
+ if (nonopt_start != -1 && nonopt_end == -1)
+ nonopt_end = optind;
+
+ /*
+ * If we have "-" do nothing, if "--" we are done.
+ */
+ if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+ optind++;
+ place = EMSG;
+ /*
+ * We found an option (--), so if we skipped
+ * non-options, we have to permute.
+ */
+ if (nonopt_end != -1) {
+ permute_args(nonopt_start, nonopt_end,
+ optind, nargv);
+ optind -= nonopt_end - nonopt_start;
+ }
+ nonopt_start = nonopt_end = -1;
+ return (-1);
+ }
+ }
+
+ /*
+ * Check long options if:
+ * 1) we were passed some
+ * 2) the arg is not just "-"
+ * 3) either the arg starts with -- we are getopt_long_only()
+ */
+ if (long_options != NULL && place != nargv[optind] &&
+ (*place == '-' || (flags & FLAG_LONGONLY))) {
+ short_too = 0;
+ if (*place == '-')
+ place++; /* --foo long option */
+ else if (*place != ':' && strchr(options, *place) != NULL)
+ short_too = 1; /* could be short option too */
+
+ optchar = parse_long_options(nargv, options, long_options,
+ idx, short_too);
+ if (optchar != -1) {
+ place = EMSG;
+ return (optchar);
+ }
+ }
+
+ if ((optchar = (int)*place++) == (int)':' ||
+ (optchar == (int)'-' && *place != '\0') ||
+ (oli = strchr(options, optchar)) == NULL) {
+ /*
+ * If the user specified "-" and '-' isn't listed in
+ * options, return -1 (non-option) as per POSIX.
+ * Otherwise, it is an unknown option character (or ':').
+ */
+ if (optchar == (int)'-' && *place == '\0')
+ return (-1);
+ if (!*place)
+ ++optind;
+ if (PRINT_ERROR)
+ fprintf(stderr, illoptchar, optchar);
+ optopt = optchar;
+ return (BADCH);
+ }
+ if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+ /* -W long-option */
+ if (*place) /* no space */
+ /* NOTHING */;
+ else if (++optind >= nargc) { /* no arg */
+ place = EMSG;
+ if (PRINT_ERROR)
+ fprintf(stderr, recargchar, optchar);
+ optopt = optchar;
+ return (BADARG);
+ } else /* white space */
+ place = nargv[optind];
+ optchar = parse_long_options(nargv, options, long_options,
+ idx, 0);
+ place = EMSG;
+ return (optchar);
+ }
+ if (*++oli != ':') { /* doesn't take argument */
+ if (!*place)
+ ++optind;
+ } else { /* takes (optional) argument */
+ optarg = NULL;
+ if (*place) /* no white space */
+ optarg = place;
+ else if (oli[1] != ':') { /* arg not optional */
+ if (++optind >= nargc) { /* no arg */
+ place = EMSG;
+ if (PRINT_ERROR)
+ fprintf(stderr, recargchar, optchar);
+ optopt = optchar;
+ return (BADARG);
+ } else
+ optarg = nargv[optind];
+ }
+ place = EMSG;
+ ++optind;
+ }
+ /* dump back option letter */
+ return (optchar);
+}
+
+/*
+ * getopt --
+ * Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the BSD getopt]
+ */
+int
+getopt(int nargc, char * const *nargv, const char *options)
+{
+
+ /*
+ * We don't pass FLAG_PERMUTE to getopt_internal() since
+ * the BSD getopt(3) (unlike GNU) has never done this.
+ *
+ * Furthermore, since many privileged programs call getopt()
+ * before dropping privileges it makes sense to keep things
+ * as simple (and bug-free) as possible.
+ */
+ return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
+}
+
+/*
+ * getopt_long --
+ * Parse argc/argv argument vector.
+ */
+int
+getopt_long(int nargc, char * const *nargv, const char *options,
+ const struct option *long_options, int *idx)
+{
+
+ return (getopt_internal(nargc, nargv, options, long_options, idx,
+ FLAG_PERMUTE));
+}
+
+/*
+ * getopt_long_only --
+ * Parse argc/argv argument vector.
+ */
+int
+getopt_long_only(int nargc, char * const *nargv, const char *options,
+ const struct option *long_options, int *idx)
+{
+
+ return (getopt_internal(nargc, nargv, options, long_options, idx,
+ FLAG_PERMUTE|FLAG_LONGONLY));
+}
diff --git a/tools/glave/src/thirdparty/mhook/COPYING b/tools/glave/src/thirdparty/mhook/COPYING
new file mode 100644
index 0000000..1ca1bcf
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/COPYING
@@ -0,0 +1,20 @@
+Copyright (c) 2007-2008, Marton Anka
+Portions Copyright (c) 2007, Matt Conover
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/CMakeLists.txt b/tools/glave/src/thirdparty/mhook/disasm-lib/CMakeLists.txt
new file mode 100644
index 0000000..ac675a3
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/CMakeLists.txt
@@ -0,0 +1,30 @@
+project(disasm)
+cmake_minimum_required(VERSION 2.8)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(
+ ${SRC_DIR}/thirdparty/mhook/disasm-lib
+ ${SRC_DIR}/glvcommon
+)
+
+set(SRC_LIST
+ cpu.c
+ cpu.h
+ disasm.c
+ disasm.h
+ disasm_x86.c
+ disasm_x86.h
+ disasm_x86_tables.h
+ misc.c
+ misc.h
+)
+
+if (NOT MSVC)
+ add_compiler_flag("-fPIC")
+endif()
+
+add_library(${PROJECT_NAME} STATIC ${SRC_LIST})
+
+build_options_finalize()
+
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/cpu.c b/tools/glave/src/thirdparty/mhook/disasm-lib/cpu.c
new file mode 100644
index 0000000..6fc57b0
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/cpu.c
@@ -0,0 +1,94 @@
+// Copyright (C) 2003, Matt Conover (mconover@gmail.com)
+#include "cpu.h"
+#include <assert.h>
+
+// NOTE: this assumes default scenarios (i.e., we assume CS/DS/ES/SS and flat
+// and all have a base of 0 and limit of 0xffffffff, we don't try to verify
+// that in the GDT)
+//
+// TODO: use inline assembly to get selector for segment
+// Segment = x86 segment register (SEG_ES = 0, SEG_CS = 1, ...)
+BYTE *GetAbsoluteAddressFromSegment(BYTE Segment, DWORD Offset)
+{
+ switch (Segment)
+ {
+ // Windows uses a flat address space (except FS for x86 and GS for x64)
+ case 0: // SEG_ES
+ case 1: // SEG_CS
+ case 2: // SEG_SS
+ case 3: // SEG_DS
+ return (BYTE *)(DWORD_PTR)Offset;
+ case 4: // SEG_FS
+ case 5: // SEG_GS
+ return (BYTE *)(DWORD_PTR)Offset;
+ // Note: we're really supposed to do this, but get_teb is not implemented
+ // in this bastardized version of the disassembler.
+ // return (BYTE *)get_teb() + Offset;
+ default:
+ assert(0);
+ return (BYTE *)(DWORD_PTR)Offset;
+ }
+}
+
+#if 0
+// This is an GDT/LDT selector (pGDT+Selector)
+BYTE *GetAbsoluteAddressFromSelector(WORD Selector, DWORD Offset)
+{
+ DESCRIPTOR_ENTRY Entry;
+ GATE_ENTRY *Gate;
+ ULONG_PTR Base;
+
+ assert(Selector < 0x10000);
+ if (!GetThreadSelectorEntry(GetCurrentThread(), Selector, (LDT_ENTRY *)&Entry)) return NULL;
+ if (!Entry.Present) return NULL;
+ if (Entry.System)
+ {
+ Base = 0;
+#ifdef _WIN64
+ Base |= (ULONG_PTR)Entry.HighOffset64 << 32;
+#endif
+ Base |= Entry.BaseHi << 24;
+ Base |= Entry.BaseMid << 16;
+ Base |= Entry.BaseLow;
+ }
+ else
+ {
+ switch (Entry.Type)
+ {
+ case 1: // 16-bit TSS (available)
+ case 2: // LDT
+ case 3: // 16-bit TSS (busy)
+ case 9: // 32-bit TSS (available)
+ case 11: // 32-bit TSS (busy)
+ Base = 0;
+#ifdef _WIN64
+ Base |= (ULONG_PTR)Entry.HighOffset64 << 32;
+#endif
+ Base |= Entry.BaseHi << 24;
+ Base |= Entry.BaseMid << 16;
+ Base |= Entry.BaseLow;
+ break;
+
+ case 4: // 16-bit call gate
+ case 5: // task gate
+ case 6: // 16-bit interrupt gate
+ case 7: // 16-bit task gate
+ case 12: // 32-bit call gate
+ case 14: // 32-bit interrupt gate
+ case 15: // 32-bit trap gate
+ Gate = (GATE_ENTRY *)&Entry;
+#ifdef _WIN64
+ Base = ((ULONG_PTR)Gate->HighOffset64 << 32) | (Gate->HighOffset << 16) | Gate->LowOffset;
+#else
+ Base = (Gate->HighOffset << 16) | Gate->LowOffset;
+#endif
+ assert(!Offset); Offset = 0;
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+ }
+ return (BYTE *)Base + Offset;
+}
+#endif
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/cpu.h b/tools/glave/src/thirdparty/mhook/disasm-lib/cpu.h
new file mode 100644
index 0000000..677d91e
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/cpu.h
@@ -0,0 +1,277 @@
+// Copyright (C) 2003, Matt Conover (mconover@gmail.com)
+#ifndef CPU_H
+#define CPU_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#pragma pack(push,1)
+
+#include "wintypes.h"
+#include "misc.h"
+
+////////////////////////////////////////////////////////
+// System descriptors
+////////////////////////////////////////////////////////
+
+#define GDT_NULL 0
+#define GDT_R0_CODE 0x08
+#define GDT_R0_DATA 0x10
+#define GDT_R3_CODE 0x18
+#define GDT_R3_DATA 0x20
+#define GDT_TSS 0x28
+#define GDT_PCR 0x30
+#define GDT_R3_TEB 0x38
+#define GDT_VDM 0x40
+#define GDT_LDT 0x48
+#define GDT_DOUBLEFAULT_TSS 0x50
+#define GDT_NMI_TSS 0x58
+
+// 16-bit GDT entries:
+// TODO: #define GDT_ABIOS_UNKNOWN 0x60 (22F30-32F2F)
+#define GDT_ABIOS_VIDEO 0x68
+#define GDT_ABIOS_GDT 0x70 // descriptor describing ABIOS GDT itself
+#define GDT_ABIOS_NTOS 0x78 // first 64K of NTOSKRNL
+#define GDT_ABIOS_CDA 0xE8 // common data area
+#define GDT_ABIOS_CODE 0xF0 // KiI386AbiosCall
+#define GDT_ABIOS_STACK 0xF8
+
+#define SELECTOR_RPL_MASK 0x03 // bits 0-1
+#define SELECTOR_LDT 0x04 // bit 2
+
+// for data selectors
+#define DATA_ACCESS_MASK (1<<0)
+#define DATA_WRITE_ENABLE_MASK (1<<1)
+#define DATA_EXPAND_DOWN_MASK (1<<2)
+
+// for code selectors
+#define CODE_ACCESS_MASK (1<<0)
+#define CODE_READ_MASK (1<<1)
+#define CODE_CONFORMING_MASK (1<<2)
+#define CODE_FLAG (1<<3)
+
+#define TASK_GATE 5
+#define INTERRUPT_GATE 6
+#define TRAP_GATE 7
+
+typedef struct _IDT_ENTRY
+{
+ USHORT LowOffset;
+ USHORT Selector;
+ UCHAR Ignored : 5;
+ UCHAR Zero : 3;
+ UCHAR Type : 3;
+ UCHAR Is32Bit : 1;
+ UCHAR Ignored2 : 1;
+ UCHAR DPL : 2;
+ UCHAR Present : 1;
+ USHORT HighOffset;
+#ifdef _WIN64
+ ULONG HighOffset64;
+ ULONG Reserved;
+#endif
+} IDT_ENTRY, TRAP_GATE_ENTRY;
+
+typedef struct _CALL_GATE_ENTRY
+{
+ USHORT LowOffset;
+ USHORT Selector;
+ UCHAR ParameterCount: 4;
+ UCHAR Ignored : 3;
+ UCHAR Type : 5;
+ UCHAR DPL : 2;
+ UCHAR Present : 1;
+ USHORT HighOffset;
+#ifdef _WIN64
+ ULONG HighOffset64;
+ ULONG Reserved;
+#endif
+} CALL_GATE_ENTRY;
+
+typedef struct _TASK_GATE_ENTRY
+{
+ USHORT Ignored;
+ USHORT Selector;
+ UCHAR Ignored2 : 5;
+ UCHAR Zero : 3;
+ UCHAR Type : 5;
+ UCHAR DPL : 2;
+ UCHAR Present : 1;
+ USHORT Ignored3;
+} TASK_GATE_ENTRY;
+
+typedef struct _DESCRIPTOR_ENTRY
+{
+ USHORT LimitLow;
+ USHORT BaseLow;
+ UCHAR BaseMid;
+ UCHAR Type : 4; // 10EWA (code), E=ExpandDown, W=Writable, A=Accessed
+ // 11CRA (data), C=Conforming, R=Readable, A=Accessed
+ UCHAR System : 1; // if 1 then it is a gate or LDT
+ UCHAR DPL : 2; // descriptor privilege level;
+ // for data selectors, MAX(CPL, RPL) must be <= DPL to access (or else GP# fault)
+ // for non-conforming code selectors (without callgate), MAX(CPL, RPL) must be <= DPL to access (or else GP# fault)
+ // for conforming code selectors, MAX(CPL, RPL) must be >= DPL (i.e., CPL 0-2 cannot access if DPL is 3)
+ // for non-conforming code selectors (with call gate), DPL indicates lowest privilege allowed to access gate
+ UCHAR Present : 1;
+ UCHAR LimitHigh : 4;
+ UCHAR Available: 1; // aka AVL
+ UCHAR Reserved : 1;
+ UCHAR Is32Bit : 1; // aka B flag
+ UCHAR Granularity : 1; // aka G flag
+ UCHAR BaseHi : 8;
+#ifdef _WIN64
+ ULONG HighOffset64;
+ ULONG Reserved2;
+#endif
+} DESCRIPTOR_ENTRY;
+
+typedef struct _GATE_ENTRY
+{
+ USHORT LowOffset;
+ UCHAR Skip;
+ UCHAR Type : 5;
+ UCHAR DPL : 2;
+ UCHAR Present : 1;
+ USHORT HighOffset;
+#ifdef _WIN64
+ ULONG HighOffset64;
+ ULONG Reserved;
+#endif
+} GATE_ENTRY;
+
+// TODO: update for X64
+typedef struct _PTE_ENTRY
+{
+ ULONG Present : 1;
+ ULONG Write : 1;
+ ULONG Owner : 1; // E.g., user mode or supervisor mode
+ ULONG WriteThrough : 1;
+ ULONG CacheDisable : 1;
+ ULONG Accessed : 1;
+ ULONG Dirty : 1;
+ ULONG PAT : 1;
+ ULONG Global : 1;
+ ULONG CopyOnWrite : 1;
+ ULONG Prototype : 1;
+ ULONG Transition : 1;
+ ULONG Address : 20;
+} PTE_ENTRY;
+
+// TODO: update for X64
+typedef struct _PDE_ENTRY
+{
+ ULONG Present : 1;
+ ULONG Write : 1;
+ ULONG Owner : 1;
+ ULONG WriteThrough : 1;
+ ULONG CacheDisable : 1;
+ ULONG Accessed : 1;
+ ULONG Reserved1 : 1;
+ ULONG PageSize : 1;
+ ULONG Global : 1;
+ ULONG Reserved : 3;
+ ULONG Address : 20;
+} PDE_ENTRY;
+
+// TODO: update for X64
+typedef struct _IO_ACCESS_MAP
+{
+ UCHAR DirectionMap[32];
+ UCHAR IoMap[8196];
+} IO_ACCESS_MAP;
+
+#define MIN_TSS_SIZE FIELD_OFFSET(TSS_ENTRY, IoMaps)
+// TODO: update for X64
+typedef struct _TSS_ENTRY
+{
+ USHORT Backlink;
+ USHORT Reserved0;
+ ULONG Esp0;
+ USHORT Ss0;
+ USHORT Reserved1;
+ ULONG NotUsed1[4];
+ ULONG CR3;
+ ULONG Eip;
+ ULONG NotUsed2[9];
+ USHORT Es;
+ USHORT Reserved2;
+ USHORT Cs;
+ USHORT Reserved3;
+ USHORT Ss;
+ USHORT Reserved4;
+ USHORT Ds;
+ USHORT Reserved5;
+ USHORT Fs;
+ USHORT Reserved6;
+ USHORT Gs;
+ USHORT Reserved7;
+ USHORT LDT;
+ USHORT Reserved8;
+ USHORT Flags;
+ USHORT IoMapBase;
+ IO_ACCESS_MAP IoMaps[1];
+ UCHAR IntDirectionMap[32];
+} TSS_ENTRY;
+
+// TODO: update for X64
+typedef struct _TSS16_ENTRY
+{
+ USHORT Backlink;
+ USHORT Sp0;
+ USHORT Ss0;
+ USHORT Sp1;
+ USHORT Ss1;
+ USHORT Sp2;
+ USHORT Ss3;
+ USHORT Ip;
+ USHORT Flags;
+ USHORT Ax;
+ USHORT Cx;
+ USHORT Dx;
+ USHORT Bx;
+ USHORT Sp;
+ USHORT Bp;
+ USHORT Si;
+ USHORT Di;
+ USHORT Es;
+ USHORT Cs;
+ USHORT Ss;
+ USHORT Ds;
+ USHORT LDT;
+} TSS16_ENTRY;
+
+// TODO: update for X64
+typedef struct _GDT_ENTRY
+{
+ USHORT LimitLow;
+ USHORT BaseLow;
+ union {
+ struct {
+ UCHAR BaseMid;
+ UCHAR Flags1;
+ UCHAR Flags2;
+ UCHAR BaseHi;
+ } Bytes;
+ struct {
+ ULONG BaseMid : 8;
+ ULONG Type : 5;
+ ULONG Dpl : 2;
+ ULONG Pres : 1;
+ ULONG LimitHi : 4;
+ ULONG Sys : 1;
+ ULONG Reserved_0 : 1;
+ ULONG Default_Big : 1;
+ ULONG Granularity : 1;
+ ULONG BaseHi : 8;
+ } Bits;
+ } HighWord;
+} GDT_ENTRY;
+
+BYTE *GetAbsoluteAddressFromSegment(BYTE Segment, DWORD Offset);
+BYTE *GetAbsoluteAddressFromSelector(WORD Selector, DWORD Offset);
+
+#pragma pack(pop)
+#ifdef __cplusplus
+}
+#endif
+#endif // CPU_H
\ No newline at end of file
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/disasm.c b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm.c
new file mode 100644
index 0000000..9e7994d
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm.c
@@ -0,0 +1,123 @@
+// Copyright (C) 2004, Matt Conover (mconover@gmail.com)
+#undef NDEBUG
+#include <assert.h>
+#include "disasm.h"
+#ifdef __linux__
+#include <string.h>
+#endif
+#ifdef NO_SANITY_CHECKS
+#define NDEBUG
+#undef assert
+#define assert(x)
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Global variables
+//////////////////////////////////////////////////////////////////////
+
+ARCHITECTURE_FORMAT SupportedArchitectures[] =
+{
+ { ARCH_X86, &X86 },
+ { ARCH_X86_16, &X86 },
+ { ARCH_X64, &X86 },
+ { ARCH_UNKNOWN, NULL }
+};
+
+typedef struct _DISASM_ARG_INFO
+{
+ INSTRUCTION *MatchedInstruction;
+ BOOL MatchPrefix;
+ U8 *Opcode;
+ U32 OpcodeLength;
+ INSTRUCTION_TYPE InstructionType;
+ U32 Count;
+} DISASM_ARG_INFO;
+
+//////////////////////////////////////////////////////////////////////
+// Function prototypes
+//////////////////////////////////////////////////////////////////////
+
+BOOL InitInstruction(INSTRUCTION *Instruction, DISASSEMBLER *Disassembler);
+static struct _ARCHITECTURE_FORMAT *GetArchitectureFormat(ARCHITECTURE_TYPE Type);
+
+//////////////////////////////////////////////////////////////////////
+// Disassembler setup
+//////////////////////////////////////////////////////////////////////
+
+BOOL InitDisassembler(DISASSEMBLER *Disassembler, ARCHITECTURE_TYPE Architecture)
+{
+ ARCHITECTURE_FORMAT *ArchFormat;
+
+ memset(Disassembler, 0, sizeof(DISASSEMBLER));
+ Disassembler->Initialized = DISASSEMBLER_INITIALIZED;
+
+ ArchFormat = GetArchitectureFormat(Architecture);
+ if (!ArchFormat) { assert(0); return FALSE; }
+ Disassembler->ArchType = ArchFormat->Type;
+ Disassembler->Functions = ArchFormat->Functions;
+ return TRUE;
+}
+
+void CloseDisassembler(DISASSEMBLER *Disassembler)
+{
+ memset(Disassembler, 0, sizeof(DISASSEMBLER));
+}
+
+//////////////////////////////////////////////////////////////////////
+// Instruction setup
+//////////////////////////////////////////////////////////////////////
+
+BOOL InitInstruction(INSTRUCTION *Instruction, DISASSEMBLER *Disassembler)
+{
+ memset(Instruction, 0, sizeof(INSTRUCTION));
+ Instruction->Initialized = INSTRUCTION_INITIALIZED;
+ Instruction->Disassembler = Disassembler;
+ memset(Instruction->String, ' ', MAX_OPCODE_DESCRIPTION-1);
+ Instruction->String[MAX_OPCODE_DESCRIPTION-1] = '\0';
+ return TRUE;
+}
+
+// If Decode = FALSE, only the following fields are valid:
+// Instruction->Length, Instruction->Address, Instruction->Prefixes, Instruction->PrefixCount,
+// Instruction->OpcodeBytes, Instruction->Instruction->OpcodeLength, Instruction->Groups,
+// Instruction->Type, Instruction->OperandCount
+//
+// If Disassemble = TRUE, then Instruction->String is valid (also requires Decode = TRUE)
+//
+// WARNING: This will overwrite the previously obtained instruction
+INSTRUCTION *GetInstruction(DISASSEMBLER *Disassembler, U64 VirtualAddress, U8 *Address, U32 Flags)
+{
+ if (Disassembler->Initialized != DISASSEMBLER_INITIALIZED) { assert(0); return NULL; }
+ assert(Address);
+ InitInstruction(&Disassembler->Instruction, Disassembler);
+ Disassembler->Instruction.Address = Address;
+ Disassembler->Instruction.VirtualAddressDelta = VirtualAddress - (U64)Address;
+ if (!Disassembler->Functions->GetInstruction(&Disassembler->Instruction, Address, Flags))
+ {
+ assert(Disassembler->Instruction.Address == Address);
+ assert(Disassembler->Instruction.Length < MAX_INSTRUCTION_LENGTH);
+
+ // Save the address that failed, in case the lower-level disassembler didn't
+ Disassembler->Instruction.Address = Address;
+ Disassembler->Instruction.ErrorOccurred = TRUE;
+ return NULL;
+ }
+ return &Disassembler->Instruction;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Miscellaneous
+///////////////////////////////////////////////////////////////////////////
+
+static ARCHITECTURE_FORMAT *GetArchitectureFormat(ARCHITECTURE_TYPE Type)
+{
+ ARCHITECTURE_FORMAT *Format;
+ for (Format = SupportedArchitectures; Format->Type != ARCH_UNKNOWN; Format++)
+ {
+ if (Format->Type == Type) return Format;
+ }
+
+ assert(0);
+ return NULL;
+}
+
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/disasm.h b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm.h
new file mode 100644
index 0000000..b7047c8
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm.h
@@ -0,0 +1,583 @@
+// Copyright (C) 2004, Matt Conover (mconover@gmail.com)
+//
+// WARNING:
+// I wouldn't recommend changing any flags like OP_*, ITYPE_*, or *_MASK
+// aside from those marked as UNUSED. This is because the flags parts of
+// the flags are architecture independent and other are left to specific
+// architectures to define, so unless you understand the relationships
+// between them, I would leave them as is.
+
+#ifndef DISASM_H
+#define DISASM_H
+
+#include "wintypes.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __linux__
+#include <string.h>
+#endif
+#include <stdio.h>
+#include "misc.h"
+
+typedef signed char S8;
+typedef unsigned char U8;
+typedef signed short S16;
+typedef unsigned short U16;
+typedef signed int S32;
+typedef unsigned int U32;
+typedef LONG64 S64;
+typedef ULONG64 U64;
+
+#ifdef SPEEDY
+// On Visual Studio 6, making the internal functions inline makes compiling take forever
+#define INTERNAL static _inline
+#define INLINE _inline
+#else
+#define INTERNAL static
+#define INLINE
+#endif
+
+#define VALID_INSTRUCTION(i) ((i) && !((i)->ErrorOccurred))
+#define NEXT_INSTRUCTION(i) ((i)->Address + (i)->Length)
+#define DISASM_ARCH_TYPE(dis) ((dis)->ArchType)
+#define INS_ARCH_TYPE(ins) DISASM_ARCH_TYPE((ins)->Disassembler)
+
+// NOTE: these should be as big set to the maximum of the supported architectures
+#define MAX_PREFIX_LENGTH 15
+#define MAX_OPERAND_COUNT 3
+#define MAX_INSTRUCTION_LENGTH 25
+#define MAX_OPCODE_LENGTH 3
+#define MAX_OPCODE_DESCRIPTION 256
+
+/////////////////////////////////////////////////////////////////////
+// Code branch
+/////////////////////////////////////////////////////////////////////
+
+#define MAX_CODE_REFERENCE_COUNT 3
+
+typedef struct _CODE_BRANCH
+{
+ U64 Addresses[MAX_CODE_REFERENCE_COUNT]; // NULL if multiple to addresses
+ U32 Count;
+ U8 IsLoop : 1;
+ U8 IsCall : 1; // branch if false
+ U8 IsIndirect : 1; // call/jmp [Address]
+ U8 AddressOffset: 5;
+ struct _INSTRUCTION_OPERAND *Operand; // the operand containg the address
+} CODE_BRANCH;
+
+/////////////////////////////////////////////////////////////////////
+// Data references
+/////////////////////////////////////////////////////////////////////
+
+#define MAX_DATA_REFERENCE_COUNT 3
+
+typedef struct _DATA_REFERENCE
+{
+ U64 Addresses[MAX_DATA_REFERENCE_COUNT]; // NULL if multiple to addresses
+ U32 Count;
+ ULONG_PTR DataSize;
+ struct _INSTRUCTION_OPERAND *Operand; // the operand containg the address
+} DATA_REFERENCE;
+
+////////////////////////////////////////////////////////////////////
+// Instruction
+/////////////////////////////////////////////////////////////////////
+
+//
+// Instruction types (bits 0-7)
+// Instruction groups (bits 8-26)
+//
+#define ITYPE_EXEC_OFFSET (1<<8)
+#define ITYPE_ARITH_OFFSET (1<<9)
+#define ITYPE_LOGIC_OFFSET (1<<10)
+#define ITYPE_STACK_OFFSET (1<<11)
+#define ITYPE_TESTCOND_OFFSET (1<<12)
+#define ITYPE_LOAD_OFFSET (1<<13)
+#define ITYPE_ARRAY_OFFSET (1<<14)
+#define ITYPE_BIT_OFFSET (1<<15)
+#define ITYPE_FLAG_OFFSET (1<<16)
+#define ITYPE_FPU_OFFSET (1<<17)
+#define ITYPE_TRAPS_OFFSET (1<<18)
+#define ITYPE_SYSTEM_OFFSET (1<<19)
+#define ITYPE_OTHER_OFFSET (1<<20)
+#define ITYPE_UNUSED1_OFFSET (1<<21)
+#define ITYPE_UNUSED2_OFFSET (1<<22)
+#define ITYPE_UNUSED3_OFFSET (1<<23)
+#define ITYPE_UNUSED4_OFFSET (1<<24)
+#define ITYPE_UNUSED5_OFFSET (1<<25)
+#define ITYPE_UNUSED6_OFFSET (1<<26)
+#define ITYPE_EXT_UNUSED1 (1<<27)
+#define ITYPE_EXT_UNUSED2 (1<<28)
+#define ITYPE_EXT_UNUSED3 (1<<29)
+#define ITYPE_EXT_UNUSED4 (1<<30)
+#define ITYPE_EXT_UNUSED5 (1<<31)
+
+//
+// X86-specific flags (bits 27-31)
+//
+
+#define ITYPE_EXT_64 ITYPE_EXT_UNUSED1 // Use index 1 if in 64-bit mode and 0 otherwise
+#define ITYPE_EXT_MODRM ITYPE_EXT_UNUSED2 // ModRM byte may extend the opcode
+#define ITYPE_EXT_SUFFIX ITYPE_EXT_UNUSED3 // byte after ModRM/SIB/displacement is the third opcode
+#define ITYPE_EXT_PREFIX ITYPE_EXT_UNUSED4 // prefix
+#define ITYPE_EXT_FPU ITYPE_EXT_UNUSED5 // FPU instructions require special handling
+
+#define ITYPE_3DNOW_OFFSET ITYPE_UNUSED1_OFFSET
+#define ITYPE_MMX_OFFSET ITYPE_UNUSED2_OFFSET
+#define ITYPE_SSE_OFFSET ITYPE_UNUSED3_OFFSET
+#define ITYPE_SSE2_OFFSET ITYPE_UNUSED4_OFFSET
+#define ITYPE_SSE3_OFFSET ITYPE_UNUSED5_OFFSET
+
+//
+// Instruction types
+//
+
+#define ITYPE_TYPE_MASK 0x7FFFFFFF
+#define ITYPE_GROUP_MASK 0x7FFFFF00
+
+typedef enum _INSTRUCTION_TYPE
+{
+ // ITYPE_EXEC group
+ ITYPE_EXEC = ITYPE_EXEC_OFFSET,
+ ITYPE_BRANCH,
+ ITYPE_BRANCHCC, // conditional (not necessarily just flags)
+ ITYPE_CALL,
+ ITYPE_CALLCC, // conditional (not necessarily just flags)
+ ITYPE_RET,
+ ITYPE_LOOPCC,
+
+ // ITYPE_ARITH group
+ ITYPE_ARITH = ITYPE_ARITH_OFFSET,
+ ITYPE_XCHGADD,
+ ITYPE_ADD,
+ ITYPE_SUB,
+ ITYPE_MUL,
+ ITYPE_DIV,
+ ITYPE_INC,
+ ITYPE_DEC,
+ ITYPE_SHL,
+ ITYPE_SHR,
+ ITYPE_ROL,
+ ITYPE_ROR,
+
+ // ITYPE_LOGIC group
+ ITYPE_LOGIC=ITYPE_LOGIC_OFFSET,
+ ITYPE_AND,
+ ITYPE_OR,
+ ITYPE_XOR,
+ ITYPE_NOT,
+ ITYPE_NEG,
+
+ // ITYPE_STACK group
+ ITYPE_STACK=ITYPE_STACK_OFFSET,
+ ITYPE_PUSH,
+ ITYPE_POP,
+ ITYPE_PUSHA,
+ ITYPE_POPA,
+ ITYPE_PUSHF,
+ ITYPE_POPF,
+ ITYPE_ENTER,
+ ITYPE_LEAVE,
+
+ // ITYPE_TESTCOND group
+ ITYPE_TESTCOND=ITYPE_TESTCOND_OFFSET,
+ ITYPE_TEST,
+ ITYPE_CMP,
+
+ // ITYPE_LOAD group
+ ITYPE_LOAD=ITYPE_LOAD_OFFSET,
+ ITYPE_MOV,
+ ITYPE_MOVCC, // conditional
+ ITYPE_LEA,
+ ITYPE_XCHG,
+ ITYPE_XCHGCC, // conditional
+
+ // ITYPE_ARRAY group
+ ITYPE_ARRAY=ITYPE_ARRAY_OFFSET,
+ ITYPE_STRCMP,
+ ITYPE_STRLOAD,
+ ITYPE_STRMOV,
+ ITYPE_STRSTOR,
+ ITYPE_XLAT,
+
+ // ITYPE_BIT group
+ ITYPE_BIT=ITYPE_BIT_OFFSET,
+ ITYPE_BITTEST,
+ ITYPE_BITSET,
+ ITYPE_BITCLR,
+
+ // ITYPE_FLAG group
+ // PF = parify flag
+ // ZF = zero flag
+ // OF = overflow flag
+ // DF = direction flag
+ // SF = sign flag
+ ITYPE_FLAG=ITYPE_FLAG_OFFSET,
+ // clear
+ ITYPE_CLEARCF,
+ ITYPE_CLEARZF,
+ ITYPE_CLEAROF,
+ ITYPE_CLEARDF,
+ ITYPE_CLEARSF,
+ ITYPE_CLEARPF,
+ // set
+ ITYPE_SETCF,
+ ITYPE_SETZF,
+ ITYPE_SETOF,
+ ITYPE_SETDF,
+ ITYPE_SETSF,
+ ITYPE_SETPF,
+ // toggle
+ ITYPE_TOGCF,
+ ITYPE_TOGZF,
+ ITYPE_TOGOF,
+ ITYPE_TOGDF,
+ ITYPE_TOGSF,
+ ITYPE_TOGPF,
+
+ // ITYPE_FPU group
+ ITYPE_FPU=ITYPE_FPU_OFFSET,
+ ITYPE_FADD,
+ ITYPE_FSUB,
+ ITYPE_FMUL,
+ ITYPE_FDIV,
+ ITYPE_FCOMP,
+ ITYPE_FEXCH,
+ ITYPE_FLOAD,
+ ITYPE_FLOADENV,
+ ITYPE_FSTORE,
+ ITYPE_FSTOREENV,
+ ITYPE_FSAVE,
+ ITYPE_FRESTORE,
+ ITYPE_FMOVCC,
+
+ ITYPE_UNUSED1=ITYPE_UNUSED1_OFFSET,
+ ITYPE_UNUSED2=ITYPE_UNUSED2_OFFSET,
+ ITYPE_UNUSED3=ITYPE_UNUSED3_OFFSET,
+
+ // ITYPE_MMX group
+ ITYPE_MMX=ITYPE_MMX_OFFSET,
+ ITYPE_MMX_MOV,
+ ITYPE_MMX_ADD,
+ ITYPE_MMX_SUB,
+ ITYPE_MMX_MUL,
+ ITYPE_MMX_DIV,
+ ITYPE_MMX_AND,
+ ITYPE_MMX_OR,
+ ITYPE_MMX_XOR,
+ ITYPE_MMX_CMP,
+
+ // ITYPE_SSE group
+ ITYPE_SSE=ITYPE_SSE_OFFSET,
+ ITYPE_SSE_MOV,
+ ITYPE_SSE_ADD,
+ ITYPE_SSE_SUB,
+ ITYPE_SSE_MUL,
+ ITYPE_SSE_DIV,
+ ITYPE_SSE_AND,
+ ITYPE_SSE_OR,
+ ITYPE_SSE_XOR,
+ ITYPE_SSE_CMP,
+
+ // ITYPE_SSE2 group
+ ITYPE_SSE2=ITYPE_SSE2_OFFSET,
+ ITYPE_SSE2_MOV,
+ ITYPE_SSE2_ADD,
+ ITYPE_SSE2_SUB,
+ ITYPE_SSE2_MUL,
+ ITYPE_SSE2_DIV,
+ ITYPE_SSE2_AND,
+ ITYPE_SSE2_OR,
+ ITYPE_SSE2_XOR,
+ ITYPE_SSE2_CMP,
+
+ // ITYPE_SSE3 group
+ ITYPE_SSE3=ITYPE_SSE3_OFFSET,
+ ITYPE_SSE3_MOV,
+ ITYPE_SSE3_ADD,
+ ITYPE_SSE3_SUB,
+ ITYPE_SSE3_MUL,
+ ITYPE_SSE3_DIV,
+ ITYPE_SSE3_AND,
+ ITYPE_SSE3_OR,
+ ITYPE_SSE3_XOR,
+ ITYPE_SSE3_CMP,
+
+ // ITYPE_3DNOW group
+ ITYPE_3DNOW=ITYPE_3DNOW_OFFSET,
+ ITYPE_3DNOW_ADD,
+ ITYPE_3DNOW_SUB,
+ ITYPE_3DNOW_MUL,
+ ITYPE_3DNOW_DIV,
+ ITYPE_3DNOW_CMP,
+ ITYPE_3DNOW_XCHG,
+
+ // ITYPE_TRAP
+ ITYPE_TRAPS=ITYPE_TRAPS_OFFSET,
+ ITYPE_TRAP, // generate trap
+ ITYPE_TRAPCC, // conditional trap gen
+ ITYPE_TRAPRET, // return from trap
+ ITYPE_BOUNDS, // gen bounds trap
+ ITYPE_DEBUG, // gen breakpoint trap
+ ITYPE_TRACE, // gen single step trap
+ ITYPE_INVALID, // gen invalid instruction
+ ITYPE_OFLOW, // gen overflow trap
+
+ // ITYPE_SYSTEM group
+ ITYPE_SYSTEM=ITYPE_SYSTEM_OFFSET,
+ ITYPE_HALT, // halt machine
+ ITYPE_IN, // input form port
+ ITYPE_OUT, // output to port
+ ITYPE_CPUID, // identify cpu
+ ITYPE_SETIF, // allow interrupts
+ ITYPE_CLEARIF, // block interrupts
+ ITYPE_SYSCALL,
+ ITYPE_SYSCALLRET,
+
+ // ITYPE_OTHER group
+ ITYPE_OTHER = ITYPE_OTHER_OFFSET,
+ ITYPE_NOP,
+ ITYPE_BCDCONV, // convert to/from BCD
+ ITYPE_SZCONV // convert size of operand
+} INSTRUCTION_TYPE;
+
+//
+// Operand flags
+//
+
+// Type = bits 0-6 (these are mutually exclusive -- bits 0-6 will always be a power of 2))
+#define OPTYPE_NONE 0x00
+#define OPTYPE_IMM 0x01 // immediate value
+#define OPTYPE_OFFSET 0x02 // relative offset
+#define OPTYPE_FLOAT 0x03 // floating point
+#define OPTYPE_BCD 0x04
+#define OPTYPE_STRING 0x05
+#define OPTYPE_SPECIAL 0x06
+#define OPTYPE_MASK 0x7F
+
+// Flags = bits 7-23 (these can be combinations)
+// These are used in the X86 opcode table
+#define OP_REG (1<<7) // 0x80
+#define OP_SIGNED (1<<8)
+#define OP_SYS (1<<9) // parameter is an index into some system structure
+#define OP_CONDR (1<<10)
+#define OP_CONDW (1<<11)
+#define OP_UNUSED (1<<12)
+#define OP_SRC (1<<13) // operand is source operand
+#define OP_DST (1<<14) // operand is destination operand
+#define OP_EXEC (1<<15) // operand is executed
+
+#define OP_CONDE OP_CONDR
+#define OP_COND_EXEC (OP_CONDE|OP_EXEC) // executed only if the pre-conditions are met
+#define OP_COND_SRC (OP_CONDR|OP_SRC) // set only if pre-conditions are met
+#define OP_COND_DST (OP_CONDW|OP_DST) // set only if pre-conditions are met
+#define OP_COND (OP_CONDR|OP_CONDW)
+
+// Bits 16-31 are available for use outside of the opcode table, but they can only
+// be used in INSTRUCTION_OPERAND.Flags, they may conflit with the architecture specific
+// operands. For example, bits 16-31 are used in X86 for AMODE_* and OPTYPE_*
+#define OP_ADDRESS (1<<16)
+#define OP_LOCAL (1<<17)
+#define OP_PARAM (1<<18)
+#define OP_GLOBAL (1<<19)
+#define OP_FAR (1<<20)
+#define OP_IPREL (1<<21)
+
+//
+// X86-specific flags (bits 27-31)
+//
+#define OP_MSR (OP_SYS|OP_UNUSED)
+
+//
+// Other architecture flags
+//
+#define OP_DELAY OP_UNUSED // delayed instruction (e.g., delayed branch that executes after the next instruction)
+
+/////////////////////////////////////////////////////////////////////
+// Architectures
+/////////////////////////////////////////////////////////////////////
+
+typedef enum _ARCHITECTURE_TYPE
+{
+ ARCH_UNKNOWN=0,
+
+ // x86-based
+ ARCH_X86, // 32-bit x86
+ ARCH_X86_16, // 16-bit x86
+ ARCH_X64, // AMD64 and Intel EMD64
+
+ // everything else
+ ARCH_ALPHA,
+ ARCH_ARM,
+ ARCH_DOTNET,
+ ARCH_EFI,
+ ARCH_IA64,
+ ARCH_M68K,
+ ARCH_MIPS,
+ ARCH_PPC,
+ ARCH_SH3,
+ ARCH_SH4,
+ ARCH_SPARC,
+ ARCH_THUMB
+
+} ARCHITECTURE_TYPE;
+struct _INSTRUCTION;
+typedef BOOL (*INIT_INSTRUCTION)(struct _INSTRUCTION *Instruction);
+typedef void (*DUMP_INSTRUCTION)(struct _INSTRUCTION *Instruction, BOOL ShowBytes, BOOL Verbose);
+typedef BOOL (*GET_INSTRUCTION)(struct _INSTRUCTION *Instruction, U8 *Address, U32 Flags);
+typedef U8 *(*FIND_FUNCTION_BY_PROLOGUE)(struct _INSTRUCTION *Instruction, U8 *StartAddress, U8 *EndAddress, U32 Flags);
+
+typedef struct _ARCHITECTURE_FORMAT_FUNCTIONS
+{
+ INIT_INSTRUCTION InitInstruction;
+ DUMP_INSTRUCTION DumpInstruction;
+ GET_INSTRUCTION GetInstruction;
+ FIND_FUNCTION_BY_PROLOGUE FindFunctionByPrologue;
+} ARCHITECTURE_FORMAT_FUNCTIONS;
+
+typedef struct _ARCHITECTURE_FORMAT
+{
+ ARCHITECTURE_TYPE Type;
+ ARCHITECTURE_FORMAT_FUNCTIONS *Functions;
+} ARCHITECTURE_FORMAT;
+
+#define DISASSEMBLER_INITIALIZED 0x1234566F
+#define INSTRUCTION_INITIALIZED 0x1234567F
+
+#include "disasm_x86.h"
+
+typedef struct DECLSPEC_ALIGN(16) _S128
+{
+ U64 Low;
+ S64 High;
+} S128;
+typedef struct DECLSPEC_ALIGN(16) _U128
+{
+ U64 Low;
+ U64 High;
+} U128;
+
+typedef struct _INSTRUCTION_OPERAND
+{
+ U32 Flags;
+ U8 Type : 6;
+ U8 Unused : 2;
+ U16 Length;
+
+
+ // If non-NULL, this indicates the target address of the instruction (e.g., a branch or
+ // a displacement with no base register). However, this address is only reliable if the
+ // image is mapped correctly (e.g., the executable is mapped as an image and fixups have
+ // been applied if it is not at its preferred image base).
+ //
+ // If disassembling a 16-bit DOS application, TargetAddress is in the context of
+ // X86Instruction->Segment. For example, if TargetAddress is the address of a code branch,
+ // it is in the CS segment (unless X86Instruction->HasSegmentOverridePrefix is set). If
+ // TargetAddress is a data pointer, it is in the DS segment (unless
+ // X86Instruction->HasSegmentOverridePrefix is set)
+ U64 TargetAddress;
+ U32 Register;
+
+ union
+ {
+ // All 8/16/32-bit operands are extended to 64-bits automatically
+ // If you want to downcast, check whether Flags & OP_SIGNED is set
+ // Like this:
+ // U32 GetOperand32(OPERAND *Operand)
+ // {
+ // if (Operand->Flags & OP_SIGNED) return (S32)Operand->Value_S64;
+ // else return (U32)Operand->Value_U64;
+ //}
+ U64 Value_U64;
+ S64 Value_S64;
+ U128 Value_U128;
+ U128 Float128;
+ U8 Float80[80];
+ U8 BCD[10];
+ };
+} INSTRUCTION_OPERAND;
+
+typedef struct _INSTRUCTION
+{
+ U32 Initialized;
+ struct _DISASSEMBLER *Disassembler;
+
+ char String[MAX_OPCODE_DESCRIPTION];
+ U8 StringIndex;
+ U64 VirtualAddressDelta;
+
+ U32 Groups; // ITYPE_EXEC, ITYPE_ARITH, etc. -- NOTE groups can be OR'd together
+ INSTRUCTION_TYPE Type; // ITYPE_ADD, ITYPE_RET, etc. -- NOTE there is only one possible type
+
+ U8 *Address;
+ U8 *OpcodeAddress;
+ U32 Length;
+
+ U8 Prefixes[MAX_PREFIX_LENGTH];
+ U32 PrefixCount;
+
+ U8 LastOpcode; // last byte of opcode
+ U8 OpcodeBytes[MAX_OPCODE_LENGTH];
+ U32 OpcodeLength; // excludes any operands and prefixes
+
+ INSTRUCTION_OPERAND Operands[MAX_OPERAND_COUNT];
+ U32 OperandCount;
+
+ X86_INSTRUCTION X86;
+
+ DATA_REFERENCE DataSrc;
+ DATA_REFERENCE DataDst;
+ CODE_BRANCH CodeBranch;
+
+ // Direction depends on which direction the stack grows
+ // For example, on x86 a push results in StackChange < 0 since the stack grows down
+ // This is only relevant if (Group & ITYPE_STACK) is true
+ //
+ // If Groups & ITYPE_STACK is set but StackChange = 0, it means that the change
+ // couldn't be determined (non-constant)
+ LONG StackChange;
+
+ // Used to assist in debugging
+ // If set, the current instruction is doing something that requires special handling
+ // For example, popf can cause tracing to be disabled
+
+ U8 StringAligned : 1; // internal only
+ U8 NeedsEmulation : 1; // instruction does something that re
+ U8 Repeat : 1; // instruction repeats until some condition is met (e.g., REP prefix on X86)
+ U8 ErrorOccurred : 1; // set if instruction is invalid
+ U8 AnomalyOccurred : 1; // set if instruction is anomalous
+ U8 LastInstruction : 1; // tells the iterator callback it is the last instruction
+ U8 CodeBlockFirst: 1;
+ U8 CodeBlockLast : 1;
+} INSTRUCTION;
+
+typedef struct _DISASSEMBLER
+{
+ U32 Initialized;
+ ARCHITECTURE_TYPE ArchType;
+ ARCHITECTURE_FORMAT_FUNCTIONS *Functions;
+ INSTRUCTION Instruction;
+ U32 Stage1Count; // GetInstruction called
+ U32 Stage2Count; // Opcode fully decoded
+ U32 Stage3CountNoDecode; // made it through all checks when DISASM_DECODE is not set
+ U32 Stage3CountWithDecode; // made it through all checks when DISASM_DECODE is set
+} DISASSEMBLER;
+
+#define DISASM_DISASSEMBLE (1<<1)
+#define DISASM_DECODE (1<<2)
+#define DISASM_SUPPRESSERRORS (1<<3)
+#define DISASM_SHOWFLAGS (1<<4)
+#define DISASM_ALIGNOUTPUT (1<<5)
+#define DISASM_DISASSEMBLE_MASK (DISASM_ALIGNOUTPUT|DISASM_SHOWBYTES|DISASM_DISASSEMBLE)
+
+BOOL InitDisassembler(DISASSEMBLER *Disassembler, ARCHITECTURE_TYPE Architecture);
+void CloseDisassembler(DISASSEMBLER *Disassembler);
+INSTRUCTION *GetInstruction(DISASSEMBLER *Disassembler, U64 VirtualAddress, U8 *Address, U32 Flags);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // DISASM_H
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86.c b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86.c
new file mode 100644
index 0000000..2db04f3
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86.c
@@ -0,0 +1,4667 @@
+// Copyright (C) 2004, Matt Conover (mconover@gmail.com)
+#undef NDEBUG
+#include <assert.h>
+#include "disasm.h"
+#include "cpu.h"
+
+// Since addresses are internally represented as 64-bit, we need to specially handle
+// cases where IP + Displacement wraps around for 16-bit/32-bit operand size
+// Otherwise, ignorethe possibility of wraparounds
+#define SUPPORT_WRAPAROUND
+
+#ifdef NO_SANITY_CHECKS
+#undef NDEBUG
+#undef DEBUG_DISASM
+#undef assert
+#define assert(x)
+#endif
+
+#ifdef DEBUG_DISASM
+#define DISASM_OUTPUT(x) printf x
+#else
+#define DISASM_OUTPUT(x)
+#endif
+
+#include "disasm_x86_tables.h"
+
+#ifdef _WIN64
+#pragma warning(disable:4311 4312)
+#endif
+
+////////////////////////////////////////////////////////////////////////
+// Internal macros
+////////////////////////////////////////////////////////////////////////
+
+#define VIRTUAL_ADDRESS ((U64)Instruction->Address + Instruction->VirtualAddressDelta)
+
+#define AMD64_DIFF (AMD64_8BIT_OFFSET-X86_8BIT_OFFSET)
+#define IS_AMD64() (INS_ARCH_TYPE(Instruction) == ARCH_X64)
+#define IS_X86_32() (INS_ARCH_TYPE(Instruction) == ARCH_X86)
+#define IS_X86_16() (INS_ARCH_TYPE(Instruction) == ARCH_X86_16)
+
+#define X86_BOUND 0x62
+#define X86_PUSH_REG 0x50
+#define X86_PUSH_CS 0x0e
+#define X86_PUSH_DS 0x1e
+#define X86_PUSH_SS 0x16
+#define X86_PUSH_ES 0x06
+#define X86_PUSH_FS 0xa0
+#define X86_PUSH_GS 0xa8
+#define X86_PUSH_U8 0x6a
+#define X86_PUSH_U32 0x68
+#define X86_POP_DS 0x1f
+#define X86_POP_ES 0x07
+#define X86_POP_SS 0x17
+#define X86_POP_FS 0xa1
+#define X86_POP_GS 0xa9
+#define X86_POP_REG 0x58
+
+#define OPCSTR Instruction->String+Instruction->StringIndex
+#if defined(WIN32)
+#define APPEND Instruction->StringIndex += (U8)_snprintf
+#else
+#define APPEND Instruction->StringIndex += (U8)snprintf
+#endif
+
+#define APPENDPAD(x) \
+{ \
+ if (Instruction->StringAligned) \
+ { \
+ if (Instruction->StringIndex > x) assert(0); \
+ while (x != Instruction->StringIndex) APPENDB(' '); \
+ } \
+ else if (Instruction->StringIndex) \
+ { \
+ APPENDB(' '); \
+ } \
+}
+
+#define APPENDB(a) Instruction->String[Instruction->StringIndex++] = a
+#define APPENDS(a) APPEND(OPCSTR, SIZE_LEFT, a);
+
+#define SIZE_LEFT (MAX_OPCODE_DESCRIPTION-1 > Instruction->StringIndex ? MAX_OPCODE_DESCRIPTION-Instruction->StringIndex : 0)
+
+// If an address size prefix is used for an instruction that doesn't make sense, restore it
+// to the default
+
+#define SANITY_CHECK_OPERAND_SIZE() \
+{ \
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasOperandSizePrefix) \
+ { \
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Unexpected operand size prefix\n", VIRTUAL_ADDRESS); \
+ Instruction->AnomalyOccurred = TRUE; \
+ X86Instruction->HasOperandSizePrefix = FALSE; \
+ switch (X86Instruction->OperandSize) \
+ { \
+ case 4: X86Instruction->OperandSize = 2; break; \
+ case 2: X86Instruction->OperandSize = 4; break; \
+ default: assert(0); \
+ } \
+ } \
+}
+
+#define SANITY_CHECK_ADDRESS_SIZE() \
+{ \
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasAddressSizePrefix) \
+ { \
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Unexpected address size prefix\n", VIRTUAL_ADDRESS); \
+ Instruction->AnomalyOccurred = TRUE; \
+ } \
+ X86Instruction->HasAddressSizePrefix = FALSE; \
+ switch (INS_ARCH_TYPE(Instruction)) \
+ { \
+ case ARCH_X64: X86Instruction->AddressSize = 8; break; \
+ case ARCH_X86: X86Instruction->AddressSize = 4; break; \
+ case ARCH_X86_16: X86Instruction->AddressSize = 2; break; \
+ } \
+}
+
+#define SANITY_CHECK_SEGMENT_OVERRIDE() \
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasSegmentOverridePrefix) \
+ { \
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Unexpected segment override\n", VIRTUAL_ADDRESS); \
+ Instruction->AnomalyOccurred = TRUE; \
+ }
+
+#define INSTR_INC(size) \
+{ \
+ Instruction->Length += size; \
+ Address += size; \
+}
+
+#define X86_SET_TARGET() \
+{ \
+ if (X86Instruction->HasSelector) \
+ { \
+ if (!Instruction->AnomalyOccurred) \
+ { \
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: unexpected segment 0x%02X\n", VIRTUAL_ADDRESS, X86Instruction->Selector); \
+ Instruction->AnomalyOccurred = TRUE; \
+ } \
+ } \
+ else \
+ { \
+ switch (X86Instruction->Segment) \
+ { \
+ case SEG_CS: \
+ case SEG_DS: \
+ case SEG_SS: \
+ case SEG_ES: \
+ assert(!X86Instruction->HasSelector); \
+ Operand->TargetAddress = (U64)X86Instruction->Displacement; \
+ /* assert(!GetAbsoluteAddressFromSegment((BYTE)X86Instruction->Segment, (DWORD)X86Instruction->Displacement) || GetAbsoluteAddressFromSegment(X86Instruction->Segment, (DWORD)X86Instruction->Displacement) == Operand->TargetAddress); */ \
+ break; \
+ case SEG_FS: \
+ case SEG_GS: \
+ assert(!X86Instruction->HasSelector); \
+ Operand->TargetAddress = (U64)GetAbsoluteAddressFromSegment((BYTE)X86Instruction->Segment, (DWORD)X86Instruction->Displacement); \
+ break; \
+ default: \
+ assert(0); /* shouldn't be possible */ \
+ break; \
+ } \
+ } \
+}
+
+#define X86_SET_SEG(reg) \
+{ \
+ if (!X86Instruction->HasSegmentOverridePrefix && (reg == REG_EBP || reg == REG_ESP)) \
+ { \
+ assert(!X86Instruction->HasSelector); \
+ X86Instruction->Segment = SEG_SS; \
+ } \
+}
+
+#define X86_SET_ADDR() \
+{ \
+ if (Operand->Flags & OP_DST) \
+ { \
+ assert(!X86Instruction->HasDstAddressing); \
+ X86Instruction->HasDstAddressing = TRUE; \
+ X86Instruction->DstOpIndex[X86Instruction->DstOpCount] = (U8)OperandIndex; \
+ X86Instruction->DstOpCount++; \
+ X86Instruction->DstAddressIndex = (U8)OperandIndex; \
+ } \
+ if (Operand->Flags & OP_SRC) \
+ { \
+ if (Instruction->Type != ITYPE_STRCMP) assert(!X86Instruction->HasSrcAddressing); \
+ X86Instruction->HasSrcAddressing = TRUE; \
+ X86Instruction->SrcOpIndex[X86Instruction->SrcOpCount] = (U8)OperandIndex; \
+ X86Instruction->SrcOpCount++; \
+ X86Instruction->SrcAddressIndex = (U8)OperandIndex; \
+ } \
+}
+
+#define X86_SET_REG(reg) \
+{ \
+ if (Operand->Flags & OP_DST) \
+ { \
+ X86Instruction->DstOpIndex[X86Instruction->DstOpCount] = (U8)OperandIndex; \
+ X86Instruction->DstOpCount++; \
+ assert(OperandIndex < 2); \
+ if (Operand->Length > 1 && reg == REG_ESP) Instruction->Groups |= ITYPE_STACK; \
+ } \
+ if (Operand->Flags & OP_SRC) \
+ { \
+ X86Instruction->SrcOpIndex[X86Instruction->SrcOpCount] = (U8)OperandIndex; \
+ X86Instruction->SrcOpCount++; \
+ } \
+}
+
+#define CHECK_AMD64_REG() { if (IS_AMD64()) Operand->Register += AMD64_DIFF; }
+
+////////////////////////////////////////////////////////////////////////
+// Internal structures/variables
+////////////////////////////////////////////////////////////////////////
+
+ARCHITECTURE_FORMAT_FUNCTIONS X86 =
+{
+ X86_InitInstruction,
+ NULL,
+ X86_GetInstruction,
+ X86_FindFunctionByPrologue
+};
+
+char *X86_Registers[0xE0] =
+{
+ // Segments
+ "es", // 0x00
+ "cs", // 0x01
+ "ss", // 0x02
+ "ds", // 0x03
+ "fs", // 0x04
+ "gs", // 0x05
+ "flags", // 0x06
+ "eflags", // 0x07
+ "rflags", // 0x08
+ "ip+ilen", // 0x09
+ "eip+ilen", // 0x0A
+ "rip+ilen", // 0x0B
+ NULL, // 0x0C
+ NULL, // 0x0D
+ NULL, // 0x0E
+ NULL, // 0x0F
+
+ // Test
+ "tr0", // 0x10
+ "tr1", // 0x11
+ "tr2", // 0x12
+ "tr3", // 0x13
+ "tr4", // 0x14
+ "tr5", // 0x15
+ "tr6", // 0x16
+ "tr7", // 0x17
+ "tr8", // 0x18
+ "tr9", // 0x19
+ "tr10", // 0x1A
+ "tr11", // 0x1B
+ "tr12", // 0x1C
+ "tr13", // 0x1D
+ "tr14", // 0x1E
+ "tr15", // 0x1F
+
+ // Control
+ "cr0", // 0x20
+ "cr1", // 0x21
+ "cr2", // 0x22
+ "cr3", // 0x23
+ "cr4", // 0x24
+ "cr5", // 0x25
+ "cr6", // 0x26
+ "cr7", // 0x27
+ "cr8", // 0x18
+ "cr9", // 0x19
+ "cr10", // 0x1A
+ "cr11", // 0x1B
+ "cr12", // 0x1C
+ "cr13", // 0x1D
+ "cr14", // 0x1E
+ "cr15", // 0x1F
+
+ // Debug
+ "dr0", // 0x30
+ "dr1", // 0x31
+ "dr2", // 0x32
+ "dr3", // 0x33
+ "dr4", // 0x34
+ "dr5", // 0x35
+ "dr6", // 0x36
+ "dr7", // 0x37
+ "dr8", // 0x38
+ "dr9", // 0x39
+ "dr10", // 0x3A
+ "dr11", // 0x3B
+ "dr12", // 0x3C
+ "dr13", // 0x3D
+ "dr14", // 0x3E
+ "dr15", // 0x3F
+
+ // FPU
+ "st(0)", // 0x40
+ "st(1)", // 0x41
+ "st(2)", // 0x42
+ "st(3)", // 0x43
+ "st(4)", // 0x44
+ "st(5)", // 0x45
+ "st(6)", // 0x46
+ "st(7)", // 0x47
+ NULL, // 0x48
+ NULL, // 0x49
+ NULL, // 0x4A
+ NULL, // 0x4B
+ NULL, // 0x4C
+ NULL, // 0x4D
+ NULL, // 0x4E
+ NULL, // 0x4F
+
+ // MMX
+ "mm0", // 0x50
+ "mm1", //
+ "mm2",
+ "mm3",
+ "mm4",
+ "mm5",
+ "mm6",
+ "mm7",
+ NULL, // 0x58
+ NULL, // 0x59
+ NULL, // 0x5A
+ NULL, // 0x5B
+ NULL, // 0x5C
+ NULL, // 0x5D
+ NULL, // 0x5E
+ NULL, // 0x5F
+
+ // XMM
+ "xmm0", // 0x60
+ "xmm1", // 0x61
+ "xmm2", // 0x62
+ "xmm3", // 0x63
+ "xmm4", // 0x64
+ "xmm5", // 0x65
+ "xmm6", // 0x66
+ "xmm7", // 0x67
+ "xmm8", // 0x68
+ "xmm9", // 0x69
+ "xmm10", // 0x6a
+ "xmm11", // 0x6b
+ "xmm12", // 0x6c
+ "xmm13", // 0x6d
+ "xmm14", // 0x6e
+ "xmm15", // 0x6f
+
+ // 8-bit
+ "al", // 0x70
+ "cl", // 0x71
+ "dl", // 0x72
+ "bl", // 0x73
+ "ah", // 0x74
+ "ch", // 0x75
+ "dh", // 0x76
+ "bh", // 0x77
+ NULL, // 0x78
+ NULL, // 0x79
+ NULL, // 0x7A
+ NULL, // 0x7B
+ NULL, // 0x7C
+ NULL, // 0x7D
+ NULL, // 0x7E
+ NULL, // 0x7F
+
+ // 16-bit
+ "ax", // 0x80
+ "cx", // 0x81
+ "dx", // 0x82
+ "bx", // 0x83
+ "sp", // 0x84
+ "bp", // 0x85
+ "si", // 0x86
+ "di", // 0x87
+ NULL, // 0x88
+ NULL, // 0x89
+ NULL, // 0x8A
+ NULL, // 0x8B
+ NULL, // 0x8C
+ NULL, // 0x8D
+ NULL, // 0x8E
+ NULL, // 0x8F
+
+ // 32-bit
+ "eax", // 0x90
+ "ecx", // 0x91
+ "edx", // 0x92
+ "ebx", // 0x93
+ "esp", // 0x94
+ "ebp", // 0x95
+ "esi", // 0x96
+ "edi", // 0x97
+ NULL, // 0x98
+ NULL, // 0x99
+ NULL, // 0x9A
+ NULL, // 0x9B
+ NULL, // 0x9C
+ NULL, // 0x9D
+ NULL, // 0x9E
+ NULL, // 0x9F
+
+ // X86-64 8-bit register
+ "al", // 0xA0
+ "cl", // 0xA1
+ "dl", // 0xA2
+ "bl", // 0xA3
+ "spl", // 0xA4
+ "bpl", // 0xA5
+ "sil", // 0xA6
+ "dil", // 0xA7
+ "r8b", // 0xA8
+ "r9b", // 0xA9
+ "r10b", // 0xAA
+ "r11b", // 0xAB
+ "r12b", // 0xAC
+ "r13b", // 0xAD
+ "r14b", // 0xAE
+ "r15b", // 0xAF
+
+ // X86-64 16-bit register
+ "ax", // 0xB0
+ "cx", // 0xB1
+ "dx", // 0xB2
+ "bx", // 0xB3
+ "sp", // 0xB4
+ "bp", // 0xB5
+ "si", // 0xB6
+ "di", // 0xB7
+ "r8w", // 0xB8
+ "r9w", // 0xB9
+ "r10w", // 0xBA
+ "r11w", // 0xBB
+ "r12w", // 0xBC
+ "r13w", // 0xBD
+ "r14w", // 0xBE
+ "r15w", // 0xBF
+
+ // X86-64 32-bit register
+ "eax", // 0xC0
+ "ecx", // 0xC1
+ "edx", // 0xC2
+ "ebx", // 0xC3
+ "esp", // 0xC4
+ "ebp", // 0xC5
+ "esi", // 0xC6
+ "edi", // 0xC7
+ "r8d", // 0xC8
+ "r9d", // 0xC9
+ "r10d", // 0xCA
+ "r11d", // 0xCB
+ "r12d", // 0xCC
+ "r13d", // 0xCD
+ "r14d", // 0xCE
+ "r15d", // 0xCF
+
+ // X86-64 64-bit register
+ "rax", // 0xD0
+ "rcx", // 0xD1
+ "rdx", // 0xD2
+ "rbx", // 0xD3
+ "rsp", // 0xD4
+ "rbp", // 0xD5
+ "rsi", // 0xD6
+ "rdi", // 0xD7
+ "r8", // 0xD8
+ "r9", // 0xD9
+ "r10", // 0xDA
+ "r11", // 0xDB
+ "r12", // 0xDC
+ "r13", // 0xDD
+ "r14", // 0xDE
+ "r15" // 0xDF
+};
+
+void OutputBounds(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputGeneral(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputDescriptor(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputSegOffset(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputPackedReal(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputPackedBCD(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputScalarReal(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputScalarGeneral(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputFPUEnvironment(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputFPUState(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+void OutputCPUState(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+
+typedef void (*OUTPUT_OPTYPE)(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex);
+#define OPTYPE_SHIFT 24
+#define MAX_OPTYPE_INDEX 26
+OUTPUT_OPTYPE OptypeHandlers[] =
+{
+ NULL,
+ OutputBounds, // 01 OPTYPE_a
+ OutputGeneral, // 02 OPTYPE_b
+ OutputGeneral, // 03 OPTYPE_d
+ OutputSegOffset, // 04 OPTYPE_p
+ OutputGeneral, // 05 OPTYPE_q
+ OutputDescriptor, // 06 OPTYPE_dt
+ OutputGeneral, // 07 OPTYPE_v
+ OutputGeneral, // 08 OPTYPE_w
+ OutputPackedReal, // 09 OPTYPE_ps
+ OutputPackedReal, // 0A OPTYPE_pd
+ OutputPackedBCD, // 0B OPTYPE_pb
+ OutputScalarReal, // 0C OPTYPE_ss
+ OutputScalarReal, // 0D OPTYPE_sd
+ OutputScalarReal, // 0E OPTYPE_se
+ OutputFPUEnvironment, // 0F OPTYPE_fev
+ OutputFPUState, // 10 OPTYPE_fst1
+ OutputFPUState, // 11 OPTYPE_fst2
+ OutputGeneral, // 12 OPTYPE_z
+ OutputGeneral, // 13 OPTYPE_o
+ OutputGeneral, // 14 OPTYPE_dq
+ OutputGeneral, // 15 OPTYPE_mw
+ OutputScalarGeneral, // 16 OPTYPE_sso
+ OutputScalarGeneral, // 17 OPTYPE_sdo
+ OutputCPUState, // 18 OPTYPE_cpu
+ OutputGeneral, // 19 OPTYPE_lea
+};
+
+#define OPTYPE_a 0x01000000
+#define OPTYPE_b 0x02000000
+#define OPTYPE_d 0x03000000
+#define OPTYPE_p 0x04000000
+#define OPTYPE_q 0x05000000
+#define OPTYPE_dt 0x06000000
+#define OPTYPE_v 0x07000000
+#define OPTYPE_w 0x08000000
+#define OPTYPE_ps 0x09000000 // packed 128-bit single real
+#define OPTYPE_pd 0x0A000000 // packed 128-bit double real
+#define OPTYPE_pb 0x0B000000 // packed BCD (10 bytes, 18-bit precision)
+#define OPTYPE_ss 0x0C000000 // scalar single real
+#define OPTYPE_sd 0x0D000000 // scalar double real
+#define OPTYPE_se 0x0E000000 // scalar extended real
+#define OPTYPE_fev 0x0F000000 // FPU environment (28 bytes if 32-bit modes, 14 bytes in 16-bit mode)
+#define OPTYPE_fst1 0x10000000 // FPU state (108 bytes in 32-bit modes, 94 bytes in 16-bit real mode)
+#define OPTYPE_fst2 0x11000000 // FPU/MMX/XMM/MXCSR state (512 bytes)
+#define OPTYPE_z 0x12000000
+#define OPTYPE_o 0x13000000
+#define OPTYPE_dq 0x14000000 // OPTYPE_d or OPTYPE_o
+#define OPTYPE_mw 0x15000000 // word if memory, register size otherwise
+#define OPTYPE_sso 0x16000000 // OPTYPE_ss or OPTYPE_o
+#define OPTYPE_sdo 0x17000000 // OPTYPE_ss or OPTYPE_o
+#define OPTYPE_cpu 0x18000000 // pointer to CPU state structure
+#define OPTYPE_lea 0x19000000 // size set by other operand
+
+////////////////////////////////////////////////////////////////////////
+// Internal functions
+////////////////////////////////////////////////////////////////////////
+
+#ifdef TEST_DISASM // TODO: remove
+U32 X86_GetLength(INSTRUCTION *Instruction, U8 *Address);
+#endif
+
+INTERNAL BOOL IsValidLockPrefix(X86_INSTRUCTION *Instruction, U8 Opcode, U32 OpcodeLength, U8 Group, U8 OpcodeExtension);
+INTERNAL U8 *SetOperands(INSTRUCTION *Instruction, U8 *Address, U32 Flags);
+INTERNAL U8 *SetModRM32(INSTRUCTION *Instruction, U8 *Address, INSTRUCTION_OPERAND *Operand, U32 OperandIndex, BOOL SuppressErrors);
+INTERNAL U8 *SetModRM16(INSTRUCTION *Instruction, U8 *Address, INSTRUCTION_OPERAND *Operand, U32 OperandIndex, BOOL SuppressErrors);
+INTERNAL U8 *SetSIB(INSTRUCTION *Instruction, U8 *Address, INSTRUCTION_OPERAND *Operand, U32 OperandIndex, BOOL SuppressErrors);
+INTERNAL U64 ApplyDisplacement(U64 Address, INSTRUCTION *Instruction);
+
+//////////////////////////////////////////////////////////
+// Instruction setup
+//////////////////////////////////////////////////////////
+
+#define APPLY_OFFSET(addr) \
+{ \
+ switch (X86Instruction->OperandSize) \
+ { \
+ case 8: addr = ((U64)(addr + Instruction->VirtualAddressDelta)); break; \
+ case 4: addr = (U64)((U32)(addr + Instruction->VirtualAddressDelta)); break; \
+ case 2: addr = (U64)((U8)(addr + Instruction->VirtualAddressDelta)); break; \
+ default: assert(0); break; \
+ } \
+}
+
+BOOL X86_InitInstruction(INSTRUCTION *Instruction)
+{
+ X86_INSTRUCTION *X86Instruction;
+#ifdef NO_SANITY_CHECKS
+ assert(0); // be sure assertions are disabled
+#endif
+ X86Instruction = &Instruction->X86;
+ memset(X86Instruction, 0, sizeof(X86_INSTRUCTION));
+
+ switch (INS_ARCH_TYPE(Instruction))
+ {
+ case ARCH_X64:
+ X86Instruction->AddressSize = 8;
+ X86Instruction->OperandSize = 4;
+ break;
+ case ARCH_X86:
+ X86Instruction->AddressSize = 4;
+ X86Instruction->OperandSize = 4;
+ break;
+ case ARCH_X86_16:
+ X86Instruction->AddressSize = 2;
+ X86Instruction->OperandSize = 2;
+ break;
+ default:
+ assert(0);
+ return FALSE;
+ }
+ X86Instruction->Instruction = Instruction;
+ X86Instruction->Segment = SEG_DS;
+ return TRUE;
+}
+
+////////////////////////////////////////////////////////////
+// Formatting
+// You can change these to whatever you prefer
+////////////////////////////////////////////////////////////
+
+#define X86_WRITE_OPFLAGS() \
+ if (Flags & DISASM_SHOWFLAGS) \
+ { \
+ APPENDB('{'); \
+ assert(Operand->Flags & (OP_EXEC|OP_SRC|OP_DST)); \
+ if (Operand->Flags & OP_IPREL) APPENDB('r'); \
+ if (Operand->Flags & OP_FAR) APPENDB('f'); \
+ if (Operand->Flags & OP_CONDR) APPENDB('c'); \
+ if (Operand->Flags & OP_EXEC) APPENDB('X'); \
+ else if (Operand->Flags & OP_SRC) APPENDB('R'); \
+ if (Operand->Flags & OP_CONDW) APPENDB('c'); \
+ if (Operand->Flags & OP_DST) APPENDB('W'); \
+ if (Operand->Flags & OP_SYS) APPENDB('S'); \
+ if (Operand->Flags & OP_ADDRESS) APPENDB('A'); \
+ if (Operand->Flags & OP_PARAM) APPENDB('P'); \
+ if (Operand->Flags & OP_LOCAL) APPENDB('L'); \
+ if (Operand->Flags & OP_GLOBAL) APPENDB('G'); \
+ APPENDB('}'); \
+ }
+
+#define X86_WRITE_IMMEDIATE() \
+{ \
+ switch (Operand->Length) \
+ { \
+ case 8: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%02I64X=", Operand->Value_U64); \
+ if (Operand->Value_S64 >= 0 || !(Operand->Flags & OP_SIGNED)) APPEND(OPCSTR, SIZE_LEFT, "%I64u", Operand->Value_U64); \
+ /*else APPEND(OPCSTR, SIZE_LEFT, "-0x%02I64X=%I64d", -Operand->Value_S64, Operand->Value_S64);*/ \
+ else APPEND(OPCSTR, SIZE_LEFT, "%I64d", Operand->Value_S64); \
+ break; \
+ case 4: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%02lX=", (U32)Operand->Value_U64); \
+ if (Operand->Value_S64 >= 0 || !(Operand->Flags & OP_SIGNED)) APPEND(OPCSTR, SIZE_LEFT, "%lu", (U32)Operand->Value_U64); \
+ /*else APPEND(OPCSTR, SIZE_LEFT, "-0x%02lX=%ld", (U32)-Operand->Value_S64, (S32)Operand->Value_S64);*/ \
+ else APPEND(OPCSTR, SIZE_LEFT, "%ld", (S32)Operand->Value_S64); \
+ break; \
+ case 2: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%02X=", (U16)Operand->Value_U64); \
+ if (Operand->Value_S64 >= 0 || !(Operand->Flags & OP_SIGNED)) APPEND(OPCSTR, SIZE_LEFT, "%u", (U16)Operand->Value_U64); \
+ /*else APPEND(OPCSTR, SIZE_LEFT, "-0x%02X=%d", (U16)-Operand->Value_S64, (S16)Operand->Value_S64);*/ \
+ else APPEND(OPCSTR, SIZE_LEFT, "%d", (S16)Operand->Value_S64); \
+ break; \
+ case 1: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%02X=", (U8)Operand->Value_U64); \
+ if (Operand->Value_S64 >= 0 || !(Operand->Flags & OP_SIGNED)) APPEND(OPCSTR, SIZE_LEFT, "%u", (U8)Operand->Value_U64); \
+ /*else APPEND(OPCSTR, SIZE_LEFT, "-0x%02X=%d", (U8)-Operand->Value_S64, (S8)Operand->Value_S64);*/ \
+ else APPEND(OPCSTR, SIZE_LEFT, "%d", (S8)Operand->Value_S64); \
+ break; \
+ default: assert(0); break; \
+ } \
+}
+
+#define X86_WRITE_ABSOLUTE_DISPLACEMENT() \
+{ \
+ switch (X86Instruction->AddressSize) \
+ { \
+ case 8: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%04I64X", X86Instruction->Displacement); \
+ break; \
+ case 4: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%04lX", (U32)X86Instruction->Displacement); \
+ break; \
+ case 2: \
+ APPEND(OPCSTR, SIZE_LEFT, "0x%04X", (U16)X86Instruction->Displacement); \
+ break; \
+ default: assert(0); break; \
+ } \
+}
+
+#define X86_WRITE_RELATIVE_DISPLACEMENT64() \
+ if (X86Instruction->Displacement >= 0) APPEND(OPCSTR, SIZE_LEFT, "+0x%02I64X", X86Instruction->Displacement); \
+ else APPEND(OPCSTR, SIZE_LEFT, "-0x%02I64X", -X86Instruction->Displacement);
+
+#define X86_WRITE_RELATIVE_DISPLACEMENT32() \
+ if (X86Instruction->Displacement >= 0) APPEND(OPCSTR, SIZE_LEFT, "+0x%02lX", (U32)X86Instruction->Displacement); \
+ else APPEND(OPCSTR, SIZE_LEFT, "-0x%02lX", (U32)-X86Instruction->Displacement);
+
+#define X86_WRITE_RELATIVE_DISPLACEMENT16() \
+ if (X86Instruction->Displacement >= 0) APPEND(OPCSTR, SIZE_LEFT, "+0x%02X", (U16)X86Instruction->Displacement); \
+ else APPEND(OPCSTR, SIZE_LEFT, "-0x%02X", (U16)-X86Instruction->Displacement);
+
+#define X86_WRITE_RELATIVE_DISPLACEMENT() \
+{ \
+ switch (X86Instruction->AddressSize) \
+ { \
+ case 8: \
+ X86_WRITE_RELATIVE_DISPLACEMENT64() \
+ break; \
+ case 4: \
+ X86_WRITE_RELATIVE_DISPLACEMENT32() \
+ break; \
+ case 2: \
+ X86_WRITE_RELATIVE_DISPLACEMENT16() \
+ break; \
+ default: assert(0); break; \
+ } \
+}
+
+#define X86_WRITE_IP_OFFSET(op) \
+{ \
+ switch (X86Instruction->OperandSize) \
+ { \
+ case 8: \
+ APPENDS("[rip+ilen"); \
+ assert((op)->TargetAddress); \
+ X86_WRITE_RELATIVE_DISPLACEMENT64() \
+ APPEND(OPCSTR, SIZE_LEFT, "]=0x%04I64X", (op)->TargetAddress+Instruction->VirtualAddressDelta); \
+ break; \
+ case 4: \
+ APPENDS("[eip+ilen"); \
+ assert((op)->TargetAddress); \
+ X86_WRITE_RELATIVE_DISPLACEMENT32() \
+ APPEND(OPCSTR, SIZE_LEFT, "]=0x%04lX", (U32)((op)->TargetAddress+Instruction->VirtualAddressDelta)); \
+ break; \
+ case 2: \
+ APPENDS("[ip+ilen"); \
+ X86_WRITE_RELATIVE_DISPLACEMENT16() \
+ APPEND(OPCSTR, SIZE_LEFT, "]=0x%04X", (U16)((op)->TargetAddress+Instruction->VirtualAddressDelta)); \
+ break; \
+ default: assert(0); break; \
+ } \
+}
+
+#define X86_WRITE_OFFSET(op) \
+{ \
+ assert((op)->Length <= 8); \
+ if (X86Instruction->HasSelector) \
+ { \
+ assert((op)->Flags & OP_FAR); \
+ APPEND(OPCSTR, SIZE_LEFT, "%s 0x%02X:[", DataSizes[((op)->Length >> 1)], X86Instruction->Selector); \
+ } \
+ else \
+ { \
+ assert(!((op)->Flags & OP_FAR)); \
+ assert(X86Instruction->Segment < SEG_MAX) ; \
+ APPEND(OPCSTR, SIZE_LEFT, "%s %s:[", DataSizes[((op)->Length >> 1)], Segments[X86Instruction->Segment]); \
+ } \
+ X86_WRITE_ABSOLUTE_DISPLACEMENT() \
+ APPENDB(']'); \
+}
+
+void OutputAddress(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ BOOL ShowDisplacement = FALSE;
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+
+ assert(!X86Instruction->HasSelector);
+ assert(X86Instruction->SrcAddressIndex == OperandIndex || X86Instruction->DstAddressIndex == OperandIndex);
+ if (Operand->Length > 16 || (Operand->Length > 1 && (Operand->Length & 1))) APPEND(OPCSTR, SIZE_LEFT, "%d_byte ptr ", Operand->Length);
+ else APPEND(OPCSTR, SIZE_LEFT, "%s ", DataSizes[Operand->Length >> 1]);
+
+ //
+ // This attempts to display the address intelligently
+ // If it has a positive 32-bit displacement, it is shown as seg:Displacement[base+index*scale]
+ // If it is a negative displacement or 8-bit, it is shown as seg:[base+index*scale+displacement]
+ //
+ APPEND(OPCSTR, SIZE_LEFT, "%s:", Segments[X86Instruction->Segment]);
+ if (X86Instruction->HasBaseRegister)
+ {
+ if (X86Instruction->Displacement)
+ {
+ if (X86Instruction->HasFullDisplacement) X86_WRITE_ABSOLUTE_DISPLACEMENT()
+ else ShowDisplacement = TRUE;
+ }
+ APPEND(OPCSTR, SIZE_LEFT, "[%s", X86_Registers[X86Instruction->BaseRegister]);
+ if (X86Instruction->HasIndexRegister)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "+%s", X86_Registers[X86Instruction->IndexRegister]);
+ if (X86Instruction->Scale > 1) APPEND(OPCSTR, SIZE_LEFT, "*%d", X86Instruction->Scale);
+ }
+ if (ShowDisplacement) X86_WRITE_RELATIVE_DISPLACEMENT()
+ APPENDB(']');
+ if (X86Instruction->Relative)
+ {
+ U64 Address = Operand->TargetAddress;
+ assert(Address);
+ APPLY_OFFSET(Address)
+ APPEND(OPCSTR, SIZE_LEFT, "=[0x%04I64X]", Address);
+ }
+ }
+ else if (X86Instruction->HasIndexRegister)
+ {
+ if (X86Instruction->Displacement)
+ {
+ if (X86Instruction->HasFullDisplacement) X86_WRITE_ABSOLUTE_DISPLACEMENT()
+ else ShowDisplacement = TRUE;
+ }
+ APPEND(OPCSTR, SIZE_LEFT, "[%s", X86_Registers[X86Instruction->IndexRegister]);
+ if (X86Instruction->Scale > 1) APPEND(OPCSTR, SIZE_LEFT, "*%d", X86Instruction->Scale);
+ if (ShowDisplacement) X86_WRITE_RELATIVE_DISPLACEMENT()
+ APPENDB(']');
+ }
+ else // just a displacement
+ {
+ APPENDB('[');
+ X86_WRITE_ABSOLUTE_DISPLACEMENT()
+ APPENDB(']');
+ }
+}
+
+void OutputBounds(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ assert(X86Instruction->HasSrcAddressing);
+ assert(!(Operand->Length & 1));
+ Operand->Length >>= 1;
+ APPENDB('(');
+ OutputAddress(Instruction, Operand, OperandIndex);
+ APPENDS(", ");
+ X86Instruction->Displacement += Operand->Length;
+ OutputAddress(Instruction, Operand, OperandIndex);
+ X86Instruction->Displacement -= Operand->Length;
+ APPENDB(')');
+ Operand->Length <<= 1;
+}
+
+void OutputGeneral(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ if ((X86Instruction->HasDstAddressing && X86Instruction->DstAddressIndex == OperandIndex) ||
+ (X86Instruction->HasSrcAddressing && X86Instruction->SrcAddressIndex == OperandIndex))
+ {
+ OutputAddress(Instruction, Operand, OperandIndex);
+ }
+ else
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ }
+}
+
+void OutputDescriptor(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ assert(X86Instruction->HasSrcAddressing || X86Instruction->HasDstAddressing);
+ OutputAddress(Instruction, Operand, OperandIndex);
+}
+
+void OutputPackedReal(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ if ((X86Instruction->HasDstAddressing && X86Instruction->DstAddressIndex == OperandIndex) ||
+ (X86Instruction->HasSrcAddressing && X86Instruction->SrcAddressIndex == OperandIndex))
+ {
+ OutputAddress(Instruction, Operand, OperandIndex);
+ }
+ else
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ }
+}
+
+void OutputPackedBCD(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ if ((X86Instruction->HasDstAddressing && X86Instruction->DstAddressIndex == OperandIndex) ||
+ (X86Instruction->HasSrcAddressing && X86Instruction->SrcAddressIndex == OperandIndex))
+ {
+ OutputAddress(Instruction, Operand, OperandIndex);
+ }
+ else
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ }
+}
+
+void OutputScalarReal(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ if ((X86Instruction->HasDstAddressing && X86Instruction->DstAddressIndex == OperandIndex) ||
+ (X86Instruction->HasSrcAddressing && X86Instruction->SrcAddressIndex == OperandIndex))
+ {
+ OutputAddress(Instruction, Operand, OperandIndex);
+ }
+ else
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ }
+}
+
+void OutputScalarGeneral(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ if (Operand->Type == OPTYPE_FLOAT)
+ {
+ OutputScalarReal(Instruction, Operand, OperandIndex);
+ }
+ else
+ {
+ OutputGeneral(Instruction, Operand, OperandIndex);
+ }
+}
+
+void OutputFPUEnvironment(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ assert(X86Instruction->HasSrcAddressing || X86Instruction->HasDstAddressing);
+ OutputAddress(Instruction, Operand, OperandIndex);
+}
+
+void OutputFPUState(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ assert(X86Instruction->HasSrcAddressing || X86Instruction->HasDstAddressing);
+ OutputAddress(Instruction, Operand, OperandIndex);
+}
+
+void OutputCPUState(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ assert(X86Instruction->HasSrcAddressing);
+ OutputAddress(Instruction, Operand, OperandIndex);
+}
+
+void OutputSegOffset(INSTRUCTION *Instruction, INSTRUCTION_OPERAND *Operand, U32 OperandIndex)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ assert(X86Instruction->HasSrcAddressing);
+ OutputAddress(Instruction, Operand, OperandIndex);
+}
+
+////////////////////////////////////////////////////////////
+// Prologue support
+////////////////////////////////////////////////////////////
+
+typedef struct _PROLOGUE
+{
+ char *Data;
+ U32 Length;
+} PROLOGUE;
+
+PROLOGUE StandardPrologues[] =
+{
+ { "\x55\x8b\xec", 3 },
+ { "\x55\x89\xe5", 3 },
+ { "\x83\xec", 2 },
+ { "\x81\xec", 2 },
+ // TODO: add AMD64 prologues
+ // TODO: add VS2003/VS2003 prologues
+ // TODO: add any unique prologues from other compilers
+ { NULL, 0 }
+};
+
+// Find the first function between StartAddress and EndAddress
+//
+// This will match a standard prologue and then analyze the following instructions to verify
+// it is a valid function
+U8 *X86_FindFunctionByPrologue(struct _INSTRUCTION *Instruction, U8 *StartAddress, U8 *EndAddress, U32 Flags)
+{
+ assert(0); // TODO
+ return NULL;
+}
+
+//////////////////////////////////////////////////////////
+// Instruction decoder
+//////////////////////////////////////////////////////////
+
+BOOL X86_GetInstruction(struct _INSTRUCTION *Instruction, U8 *Address, U32 Flags)
+{
+ BOOL SpecialExtension = FALSE;
+ U8 Opcode = 0, OpcodeExtension = 0, Group = 0, SSE_Prefix = 0, Suffix;
+ U32 i = 0, Result = 0, tmpScale;
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ X86_OPCODE *X86Opcode;
+#ifdef TEST_DISASM
+ U32 InstructionLength = 0;
+#endif
+ INSTRUCTION_OPERAND *Operand, *Operand1 = NULL;
+ DISASSEMBLER *Disassembler = Instruction->Disassembler;
+ BOOL Decode = Flags & DISASM_DECODE;
+ BOOL Disassemble = Flags & DISASM_DISASSEMBLE;
+ BOOL SuppressErrors = Flags & DISASM_SUPPRESSERRORS;
+
+ if (Disassemble && !Decode)
+ {
+ assert(0);
+ Decode = TRUE;
+ }
+
+ if (!Address || !X86_InitInstruction(Instruction))
+ {
+ assert(0);
+ goto abort;
+ }
+
+ assert(Instruction->Address == Address);
+ assert(!Instruction->StringIndex && !Instruction->Length);
+
+ Disassembler->Stage1Count++;
+ if (Flags & DISASM_ALIGNOUTPUT) Instruction->StringAligned = TRUE;
+
+ //
+ // Get prefixes or three byte opcode
+ //
+ while (TRUE)
+ {
+ Opcode = *Address;
+ INSTR_INC(1); // increment Instruction->Length and address
+ X86Opcode = &X86_Opcodes_1[Opcode];
+
+ // Handle a misplaced REX prefix -- AMD64 manual says it is just ignored
+ if (IS_AMD64() && (Opcode >= REX_PREFIX_START && Opcode <= REX_PREFIX_END) && X86_PREFIX((&X86_Opcodes_1[*Address])))
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: REX prefix before legacy prefix 0x%02X\n", VIRTUAL_ADDRESS, Opcode);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ continue;
+ }
+
+ if (X86_PREFIX(X86Opcode))
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ for (i = 0; i < Instruction->PrefixCount; i++)
+ {
+ if (Instruction->Prefixes[i] == Opcode)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Duplicate prefix 0x%02X\n", VIRTUAL_ADDRESS, Opcode);
+ Instruction->AnomalyOccurred = TRUE;
+ break;
+ }
+ }
+ }
+
+ switch (Opcode)
+ {
+ case PREFIX_REPNE: // may be three byte opcode
+ SSE_Prefix = Opcode;
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasRepeatWhileEqualPrefix)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Conflicting prefix\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ Instruction->Repeat = TRUE;
+ X86Instruction->HasRepeatWhileEqualPrefix = FALSE;
+ X86Instruction->HasRepeatWhileNotEqualPrefix = TRUE;
+ break;
+ case PREFIX_REP: // may be three byte opcode
+ SSE_Prefix = Opcode;
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasRepeatWhileNotEqualPrefix)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Conflicting prefix\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+
+ Instruction->Repeat = TRUE;
+ X86Instruction->HasRepeatWhileNotEqualPrefix = FALSE;
+ X86Instruction->HasRepeatWhileEqualPrefix = TRUE;
+ break;
+
+ case PREFIX_OPERAND_SIZE: // may be three byte opcode
+ SSE_Prefix = Opcode;
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasOperandSizePrefix)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Conflicting prefix\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+
+ if (X86Instruction->HasOperandSizePrefix) break;
+ else X86Instruction->HasOperandSizePrefix = TRUE;
+ switch (X86Instruction->OperandSize)
+ {
+ case 4: X86Instruction->OperandSize = 2; break;
+ case 2: X86Instruction->OperandSize = 4; break;
+ default: assert(0); goto abort;
+ }
+ break;
+
+ case PREFIX_ADDRESS_SIZE:
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasAddressSizePrefix)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Conflicting prefix\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+
+ if (X86Instruction->HasAddressSizePrefix) break;
+ else X86Instruction->HasAddressSizePrefix = TRUE;
+ switch (X86Instruction->AddressSize)
+ {
+ case 8:
+ X86Instruction->AddressSize = 4;
+ break;
+ case 4:
+ assert(!IS_AMD64()); // this should not be possible
+ X86Instruction->AddressSize = 2;
+ break;
+ case 2:
+ X86Instruction->AddressSize = 4;
+ break;
+ default:
+ assert(0); goto abort;
+ }
+ break;
+
+ case PREFIX_SEGMENT_OVERRIDE_ES:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ if (!IS_AMD64())
+ {
+ X86Instruction->HasSegmentOverridePrefix = TRUE;
+ X86Instruction->Segment = SEG_ES;
+ }
+ else if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Meaningless segment override\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ break;
+ case PREFIX_SEGMENT_OVERRIDE_CS:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ if (!IS_AMD64())
+ {
+ X86Instruction->HasSegmentOverridePrefix = TRUE;
+ X86Instruction->Segment = SEG_CS;
+ }
+ else if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Meaningless segment override\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ break;
+ case PREFIX_SEGMENT_OVERRIDE_SS:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ if (!IS_AMD64())
+ {
+ X86Instruction->HasSegmentOverridePrefix = TRUE;
+ X86Instruction->Segment = SEG_SS;
+ }
+ else if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Meaningless segment override\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ break;
+ case PREFIX_SEGMENT_OVERRIDE_DS:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ if (!IS_AMD64())
+ {
+ X86Instruction->HasSegmentOverridePrefix = TRUE;
+ X86Instruction->Segment = SEG_DS;
+ }
+ else if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Meaningless segment override\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ break;
+ case PREFIX_SEGMENT_OVERRIDE_FS:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ X86Instruction->HasSegmentOverridePrefix = TRUE;
+ X86Instruction->Segment = SEG_FS;
+ break;
+ case PREFIX_SEGMENT_OVERRIDE_GS:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ X86Instruction->HasSegmentOverridePrefix = TRUE;
+ X86Instruction->Segment = SEG_GS;
+ break;
+
+ case PREFIX_LOCK:
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasLockPrefix)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Conflicting prefix\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->HasLockPrefix = TRUE;
+ break;
+
+ default:
+ assert(0);
+ goto abort;
+ }
+
+ if (Instruction->PrefixCount >= X86_MAX_INSTRUCTION_LEN)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Reached maximum prefix count %d\n", VIRTUAL_ADDRESS, X86_MAX_PREFIX_LENGTH);
+ goto abort;
+ }
+ else if (Instruction->PrefixCount == X86_MAX_PREFIX_LENGTH)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Reached maximum prefix count %d\n", VIRTUAL_ADDRESS, X86_MAX_PREFIX_LENGTH);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+
+ assert(Instruction->AnomalyOccurred || Instruction->PrefixCount < X86_MAX_PREFIX_LENGTH);
+ Instruction->Prefixes[Instruction->PrefixCount] = Opcode;
+ Instruction->PrefixCount++;
+ //DISASM_OUTPUT(("[0x%08I64X] Prefix 0x%02X (prefix count %d)\n", VIRTUAL_ADDRESS, Opcode, Instruction->PrefixCount));
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ // Check for REX opcode
+ // This is checked here instead of the prefix loop above because it must be the
+ // last prefix
+ if (IS_AMD64() && (Opcode >= REX_PREFIX_START && Opcode <= REX_PREFIX_END))
+ {
+ if (Instruction->PrefixCount >= X86_MAX_INSTRUCTION_LEN)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Reached maximum prefix count %d\n", VIRTUAL_ADDRESS, X86_MAX_PREFIX_LENGTH);
+ goto abort;
+ }
+ else if (!Instruction->AnomalyOccurred && Instruction->PrefixCount == AMD64_MAX_PREFIX_LENGTH)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Reached maximum prefix count %d\n", VIRTUAL_ADDRESS, X86_MAX_PREFIX_LENGTH);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+
+ assert(Instruction->AnomalyOccurred || Instruction->PrefixCount < AMD64_MAX_PREFIX_LENGTH);
+
+ Instruction->Prefixes[Instruction->PrefixCount] = Opcode;
+ Instruction->PrefixCount++;
+ X86Instruction->rex_b = Opcode;
+ SET_REX(X86Instruction->rex, X86Instruction->rex_b);
+ DISASM_OUTPUT(("[0x%08I64X] REX prefix 0x%02X (prefix count %d, w=%d, r=%d, x=%d, b=%d)\n", VIRTUAL_ADDRESS, Opcode, Instruction->PrefixCount, X86Instruction->rex.w, X86Instruction->rex.r, X86Instruction->rex.x, X86Instruction->rex.b));
+
+ assert(X86Instruction->AddressSize >= 4);
+ if (X86Instruction->rex.w)
+ {
+ X86Instruction->OperandSize = 8;
+ X86Instruction->HasOperandSizePrefix = FALSE;
+ }
+ else if (X86Instruction->HasOperandSizePrefix)
+ {
+ assert(X86Instruction->OperandSize == 2);
+ }
+ else if (X86Instruction->rex_b == REX_PREFIX_START)
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: meaningless REX prefix used\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->rex_b = 0;
+ }
+
+ Opcode = *Address;
+ INSTR_INC(1); // increment Instruction->Length and address
+
+ X86Opcode = &X86_Opcodes_1[Opcode];
+ assert(!X86_PREFIX(X86Opcode));
+ }
+ //DISASM_OUTPUT(("[0x%08I64X] OperandSize = %d, AddressSize = %d\n", VIRTUAL_ADDRESS, X86Instruction->OperandSize, X86Instruction->AddressSize));
+ Instruction->LastOpcode = Opcode;
+ Instruction->OpcodeAddress = Address-1;
+
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Invalid opcode 0x%02X\n", VIRTUAL_ADDRESS, Opcode);
+ goto abort;
+ }
+
+ if (Opcode == X86_TWO_BYTE_OPCODE)
+ {
+ //
+ // Handle case that it is a group (with opcode extension), floating point, or two byte opcode
+ //
+ assert(!Instruction->OpcodeLength);
+ Instruction->LastOpcode = Opcode = *Address;
+ INSTR_INC(1); // increment Instruction->Length and address
+ assert(X86Opcode->Table == X86_Opcodes_2);
+ X86Opcode = &X86_Opcodes_2[Opcode];
+
+ //
+ // Check for errors
+ //
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Invalid two byte opcode 0x%02X 0x%02X\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode);
+ goto abort;
+ }
+
+ if (X86Instruction->AddressSize == 8)
+ {
+ if (X86_Invalid_Addr64_2[Opcode])
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Opcode 0x%02X 0x%02X (\"%s\") illegal in 64-bit mode\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode, X86Opcode->Mnemonic);
+ goto abort;
+ }
+#if 0
+ if (X86Instruction->rex_b &&
+ (GET_REX_B(X86Instruction->rex_b) && !GET_REX_B(X86_REX_2[Opcode]) ||
+ GET_REX_X(X86Instruction->rex_b) && !GET_REX_X(X86_REX_2[Opcode]) ||
+ GET_REX_R(X86Instruction->rex_b) && !GET_REX_R(X86_REX_2[Opcode]) ||
+ GET_REX_W(X86Instruction->rex_b) && !GET_REX_W(X86_REX_2[Opcode])))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal REX prefix 0x%02X for opcode 0x%02X 0x%02X\n", VIRTUAL_ADDRESS, X86Instruction->rex_b, X86_TWO_BYTE_OPCODE, Opcode);
+ assert(0);
+ goto abort;
+ }
+#endif
+ }
+
+ if (X86Instruction->OperandSize == 2 && X86_Invalid_Op16_2[Opcode])
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Opcode 0x%02X 0x%02X (\"%s\") illegal with 16-bit operand size\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode, X86Opcode->Mnemonic);
+ goto abort;
+ }
+
+ X86Instruction->HasModRM = X86_ModRM_2[Opcode];
+ if (X86Instruction->HasModRM) X86Instruction->modrm_b = *Address;
+ Instruction->OpcodeBytes[0] = X86_TWO_BYTE_OPCODE;
+ Instruction->OpcodeBytes[1] = Opcode;
+ Instruction->OpcodeLength = 2;
+
+ if (X86_SPECIAL_EXTENSION(X86Opcode))
+ {
+ DISASM_OUTPUT(("[0x%08I64X] Special opcode extension 0x%02X 0x%02X\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode));
+ SpecialExtension = TRUE;
+ goto HasSpecialExtension;
+ }
+ else if (SSE_Prefix && !X86_INVALID(&X86_SSE[Opcode])) // SSEx instruction
+ {
+ Instruction->OpcodeLength = 3;
+ Instruction->OpcodeBytes[2] = SSE_Prefix;
+ assert(Instruction->OpcodeBytes[1] == Opcode);
+
+ // Since the prefix was really an opcode extension, remove it from
+ // the prefix list
+ for (i = 0; i < Instruction->PrefixCount; i++)
+ {
+ if (Instruction->Prefixes[i]) break;
+ }
+ assert(i != Instruction->PrefixCount);
+ Instruction->PrefixCount--;
+ Instruction->Prefixes[i] = 0;
+
+ // Slide any prefixes following the removed prefix down by 1
+ memmove(&Instruction->Prefixes[i], &Instruction->Prefixes[i+1], Instruction->PrefixCount-i);
+ Instruction->Prefixes[Instruction->PrefixCount] = 0;
+ Instruction->Repeat = FALSE;
+ X86Instruction->HasRepeatWhileEqualPrefix = FALSE;
+ X86Instruction->HasRepeatWhileNotEqualPrefix = FALSE;
+ X86Instruction->HasOperandSizePrefix = FALSE;
+ if (SSE_Prefix == PREFIX_OPERAND_SIZE)
+ {
+ if (IS_AMD64() && X86Instruction->rex.w) X86Instruction->OperandSize = 8;
+ else X86Instruction->OperandSize = 4;
+ }
+
+ if (IS_X86_16())
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: SSE invalid in 16-bit mode\n", VIRTUAL_ADDRESS);
+ goto abort;
+ }
+
+ assert(X86Instruction->HasModRM);
+ switch (SSE_Prefix)
+ {
+ case PREFIX_OPERAND_SIZE: X86Opcode = &X86_SSE[0x000+Opcode]; break;
+ case PREFIX_REPNE: X86Opcode = &X86_SSE[0x100+Opcode]; break;
+ case PREFIX_REP: X86Opcode = &X86_SSE[0x200+Opcode]; break;
+ }
+
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal SSE instruction opcode 0x%02X 0x%02X + prefix 0x%02X\n", VIRTUAL_ADDRESS, Instruction->OpcodeBytes[0], Instruction->OpcodeBytes[1], Instruction->OpcodeBytes[2]);
+ goto abort;
+ }
+ else if (X86_EXTENDED_OPCODE(X86Opcode))
+ {
+ // SSE in group (13, 14, or 15)
+ OpcodeExtension = GET_MODRM_EXT(X86Instruction->modrm_b);
+ Group = X86_Groups_2[Opcode];
+ X86Instruction->Group = (U8)Group;
+ assert(Group >= 13 && Group <= 15 && X86Opcode->Table);
+ switch (SSE_Prefix)
+ {
+ case PREFIX_OPERAND_SIZE: X86Opcode = &X86Opcode->Table[0x00+OpcodeExtension]; break;
+ case PREFIX_REPNE: X86Opcode = &X86Opcode->Table[0x08+OpcodeExtension]; break;
+ case PREFIX_REP: X86Opcode = &X86Opcode->Table[0x10+OpcodeExtension]; break;
+ }
+
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal SSE instruction opcode 0x%02X 0x%02X + prefix 0x%02X + extension %d\n", VIRTUAL_ADDRESS, Instruction->OpcodeBytes[0], Instruction->OpcodeBytes[1], Instruction->OpcodeBytes[2], OpcodeExtension);
+ goto abort;
+ }
+ }
+
+ Instruction->Repeat = FALSE;
+ X86Instruction->HasRepeatWhileEqualPrefix = FALSE;
+ X86Instruction->HasRepeatWhileNotEqualPrefix = FALSE;
+ X86Instruction->HasOperandSizePrefix = FALSE;
+ switch (X86_GET_CATEGORY(X86Opcode))
+ {
+ case ITYPE_SSE: case ITYPE_SSE2: case ITYPE_SSE3: break;
+ default: assert(0); goto abort;
+ }
+ }
+ else if (X86_EXTENDED_OPCODE(X86Opcode)) // 2 byte group
+ {
+ assert(!X86Opcode->MnemonicFlags);
+ OpcodeExtension = GET_MODRM_EXT(X86Instruction->modrm_b);
+
+ assert(X86Opcode->Table);
+ X86Opcode = &X86Opcode->Table[OpcodeExtension];
+ if (X86_INVALID(X86Opcode))
+ {
+ Instruction->Length++;
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Invalid group opcode 0x%02X 0x%02X extension 0x%02X\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode, OpcodeExtension);
+ goto abort;
+ }
+
+ assert(!X86_SPECIAL_EXTENSION(X86Opcode));
+ Group = X86_Groups_2[Opcode];
+ X86Instruction->Group = (U8)Group;
+ assert(Group > 0 && Group <= 19);
+ assert(X86Opcode->Mnemonic);
+ DISASM_OUTPUT(("[0x%08I64X] Group %d (bytes 0x%02X 0x%02X) extension 0x%02X (\"%s\")\n", VIRTUAL_ADDRESS, Group, X86_TWO_BYTE_OPCODE, Opcode, OpcodeExtension, X86Opcode->Mnemonic));
+ }
+ else
+ {
+ assert(X86Opcode->Mnemonic);
+ DISASM_OUTPUT(("[0x%08I64X] Two byte opcode 0x%02X 0x%02X (\"%s\")\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode, X86Opcode->Mnemonic));
+ X86Instruction->HasModRM = X86_ModRM_2[Opcode];
+ if (X86Instruction->HasModRM) X86Instruction->modrm_b = *Address;
+ }
+ }
+ else // 1-byte opcode
+ {
+ if (X86Instruction->AddressSize == 8)
+ {
+ if (X86_Invalid_Addr64_1[Opcode])
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Opcode 0x%02X (\"%s\") illegal in 64-bit mode\n", VIRTUAL_ADDRESS, Opcode, X86Opcode->Mnemonic);
+ goto abort;
+ }
+
+#if 0
+ if (X86Instruction->rex_b &&
+ (GET_REX_B(X86Instruction->rex_b) && !GET_REX_B(X86_REX_1[Opcode]) ||
+ GET_REX_X(X86Instruction->rex_b) && !GET_REX_X(X86_REX_1[Opcode]) ||
+ GET_REX_R(X86Instruction->rex_b) && !GET_REX_R(X86_REX_1[Opcode]) ||
+ GET_REX_W(X86Instruction->rex_b) && !GET_REX_W(X86_REX_1[Opcode])))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal REX prefix 0x%02X for opcode 0x%02X\n", VIRTUAL_ADDRESS, X86Instruction->rex_b, Opcode);
+ assert(0);
+ goto abort;
+ }
+#endif
+ }
+
+ if (X86Instruction->OperandSize == 2 && X86_Invalid_Op16_1[Opcode])
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Opcode 0x%02X (\"%s\") illegal with 16-bit operand size\n", VIRTUAL_ADDRESS, Opcode, X86Opcode->Mnemonic);
+ goto abort;
+ }
+
+ Instruction->OpcodeBytes[0] = Opcode;
+ Instruction->OpcodeLength = 1;
+ X86Instruction->HasModRM = X86_ModRM_1[Opcode];
+ if (X86Instruction->HasModRM) X86Instruction->modrm_b = *Address;
+
+ if (X86_EXTENDED_OPCODE(X86Opcode)) // a group
+ {
+ assert(X86Instruction->HasModRM);
+ OpcodeExtension = GET_MODRM_EXT(*Address); // leave Address pointing at ModRM byte
+
+ if (X86_SPECIAL_EXTENSION(X86Opcode))
+ {
+ DISASM_OUTPUT(("[0x%08I64X] Special opcode extension 0x%02X 0x%02X\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode));
+ SpecialExtension = TRUE;
+ goto HasSpecialExtension;
+ }
+
+ assert(X86Opcode->Table);
+ X86Opcode = &X86Opcode->Table[OpcodeExtension];
+ if (X86_INVALID(X86Opcode))
+ {
+ Instruction->Length++;
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Invalid group opcode 0x%02X extension 0x%02X\n", VIRTUAL_ADDRESS, Opcode, OpcodeExtension);
+ goto abort;
+ }
+
+ Group = X86_Groups_1[Opcode];
+ X86Instruction->Group = (U8)Group;
+ DISASM_OUTPUT(("[0x%08I64X] Group %d (byte 0x%02X) extension 0x%02X (\"%s\")\n", VIRTUAL_ADDRESS, Group, Opcode, OpcodeExtension, X86Opcode->Mnemonic));
+ assert(Group > 0 && Group <= 17);
+ assert(X86Opcode->Mnemonic);
+ }
+ else
+ {
+ if (X86_SPECIAL_EXTENSION(X86Opcode))
+ {
+ DISASM_OUTPUT(("[0x%08I64X] Special opcode extension 0x%02X\n", VIRTUAL_ADDRESS, Opcode));
+ SpecialExtension = TRUE;
+ goto HasSpecialExtension;
+ }
+
+ DISASM_OUTPUT(("[0x%08I64X] One byte opcode 0x%02X (\"%s\")\n", VIRTUAL_ADDRESS, Opcode, X86Opcode->Mnemonic));
+ }
+ }
+
+HasSpecialExtension:
+ if (SpecialExtension)
+ {
+ if (X86Opcode->MnemonicFlags & ITYPE_EXT_MODRM)
+ {
+ assert(X86Opcode->Table);
+ assert(Instruction->OpcodeLength == 2);
+ assert(X86Instruction->HasModRM);
+ X86Opcode = &X86Opcode->Table[*Address];
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal opcode 0x%02X 0x%02X + modrm 0x%02X\n", VIRTUAL_ADDRESS, Instruction->OpcodeBytes[0], Instruction->OpcodeBytes[1], *Address);
+ goto abort;
+ }
+ else if (X86_EXTENDED_OPCODE(X86Opcode))
+ {
+ assert(!X86Opcode->MnemonicFlags);
+ OpcodeExtension = GET_MODRM_EXT(X86Instruction->modrm_b);
+
+ assert(X86Opcode->Table);
+ X86Opcode = &X86Opcode->Table[OpcodeExtension];
+ if (X86_INVALID(X86Opcode))
+ {
+ Instruction->Length++;
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Invalid group opcode 0x%02X 0x%02X extension 0x%02X\n", VIRTUAL_ADDRESS, X86_TWO_BYTE_OPCODE, Opcode, OpcodeExtension);
+ goto abort;
+ }
+
+ assert(!X86_SPECIAL_EXTENSION(X86Opcode));
+ Group = X86_Groups_2[Opcode];
+ X86Instruction->Group = (U8)Group;
+ assert(Group > 0 && Group <= 19);
+ assert(X86Opcode->Mnemonic);
+ DISASM_OUTPUT(("[0x%08I64X] Group %d (bytes 0x%02X 0x%02X) extension 0x%02X (\"%s\")\n", VIRTUAL_ADDRESS, Group, X86_TWO_BYTE_OPCODE, Opcode, OpcodeExtension, X86Opcode->Mnemonic));
+ }
+ else if (!X86_OPERAND_COUNT(X86Opcode))
+ {
+ INSTR_INC(1); // increment Instruction->Length and address
+ }
+ }
+ else if (X86Opcode->MnemonicFlags & ITYPE_EXT_FPU)
+ {
+ assert(X86Opcode->Table);
+ if (X86Instruction->modrm_b < 0xC0)
+ {
+ // It is an opcode extension, use the X86Opcode->Table
+ OpcodeExtension = GET_MODRM_EXT(X86Instruction->modrm_b);
+ X86Opcode = &X86Opcode->Table[OpcodeExtension];
+ }
+ else
+ {
+ // The whole ModRM byte is used, these start at index 0x08 in X86Opcode->Table
+ OpcodeExtension = (X86Instruction->modrm_b & 0x3F);
+ X86Opcode = &X86Opcode->Table[0x08 + OpcodeExtension];
+ }
+
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Invalid FPU opcode 0x%02X + modrm extension 0x%02X (index 0x%02X)\n", VIRTUAL_ADDRESS, Opcode, X86Instruction->modrm_b, 0x08 + OpcodeExtension);
+ goto abort;
+ }
+
+ DISASM_OUTPUT(("[0x%08I64X] FPU instruction is (\"%s\"): 0x%02X + modrm 0x%02X (index 0x%02X)\n", VIRTUAL_ADDRESS, X86Opcode->Mnemonic, Opcode, X86Instruction->modrm_b, 0x08 + OpcodeExtension));
+ if (!X86_OPERAND_COUNT(X86Opcode)) INSTR_INC(1); // increment Instruction->Length and address
+ }
+ else if (X86Opcode->MnemonicFlags & ITYPE_EXT_SUFFIX)
+ {
+ if (X86Instruction->HasOperandSizePrefix)
+ {
+ if (!Instruction->AnomalyOccurred && X86Opcode->Table == X86_3DNOW_0F)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: operand size prefix used with 3DNOW instruction\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->HasOperandSizePrefix = FALSE;
+ X86Instruction->OperandSize = 4;
+ }
+ Instruction->OperandCount = X86_OPERAND_COUNT(X86Opcode);
+ assert(Instruction->OpcodeLength == 2 && X86Instruction->HasModRM && Instruction->OperandCount == 2);
+ memcpy(&X86Instruction->Opcode, X86Opcode, sizeof(X86_OPCODE));
+ Instruction->Operands[0].Flags = X86Opcode->OperandFlags[0] & X86_OPFLAGS_MASK;
+ Instruction->Operands[1].Flags = X86Opcode->OperandFlags[1] & X86_OPFLAGS_MASK;
+ Instruction->Operands[2].Flags = X86Opcode->OperandFlags[2] & X86_OPFLAGS_MASK;
+ assert(Address == Instruction->Address + Instruction->Length);
+ if (!SetOperands(Instruction, Address, Flags & DISASM_SUPPRESSERRORS)) goto abort;
+ Suffix = Instruction->Address[Instruction->Length++];
+ Instruction->OpcodeBytes[2] = Suffix;
+ Instruction->OpcodeLength = 3;
+ X86Opcode = &X86Opcode->Table[Suffix];
+
+ if (X86_INVALID(X86Opcode))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal opcode 0x%02X 0x%02X + suffix 0x%02X\n", VIRTUAL_ADDRESS, Instruction->OpcodeBytes[0], Instruction->OpcodeBytes[1], Suffix);
+ goto abort;
+ }
+ assert(Instruction->Length >= 4 + Instruction->PrefixCount);
+ }
+ else if (X86Opcode->MnemonicFlags & ITYPE_EXT_64)
+ {
+ assert(X86Opcode->Table);
+ if (IS_AMD64()) X86Opcode = &X86Opcode->Table[1];
+ else X86Opcode = &X86Opcode->Table[0];
+ assert(!X86_INVALID(X86Opcode));
+ }
+ }
+
+ // Detect incompatibilities
+ if (IS_X86_16() && X86Opcode->CPU > CPU_I386)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Instruction \"%s\" (opcode 0x%02X) can't be used in 16-bit X86\n", VIRTUAL_ADDRESS, X86Opcode->Mnemonic, Instruction->LastOpcode);
+ goto abort;
+ }
+ if (!IS_AMD64() && X86Opcode->CPU >= CPU_AMD64)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Instruction \"%s\" (opcode 0x%02X) can only be used in X86-64\n", VIRTUAL_ADDRESS, X86Opcode->Mnemonic, Instruction->LastOpcode);
+ goto abort;
+ }
+
+ // Copy the opcode into the local structure and set the fields
+ assert(Instruction->OpcodeLength && !X86_INVALID(X86Opcode));
+ memcpy(&X86Instruction->Opcode, X86Opcode, sizeof(X86_OPCODE));
+ Instruction->Groups |= X86_GET_CATEGORY(X86Opcode);
+ assert(Instruction->Groups);
+ Instruction->Type |= X86_GET_TYPE(X86Opcode);
+ assert((U32)Instruction->Type >= Instruction->Groups);
+ Instruction->OperandCount = X86_OPERAND_COUNT(X86Opcode);
+
+ //
+ // Sanity check prefixes now that opcode is known and prefixes are resolved
+ //
+
+ // Instructions that implicitly reference the CS/DS can't have segment override prefixes
+ switch (Instruction->Type)
+ {
+ case ITYPE_PUSHF: case ITYPE_POPF:
+ case ITYPE_ENTER: case ITYPE_LEAVE:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ X86Instruction->Segment = SEG_SS;
+ break;
+ case ITYPE_RET: case ITYPE_DEBUG:
+ case ITYPE_OFLOW: case ITYPE_TRAP:
+ case ITYPE_TRAPRET:
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ X86Instruction->Segment = SEG_CS;
+ break;
+ }
+
+ // Check illegal prefixes used with FPU/MMX/SSEx
+ if (Instruction->Groups & (ITYPE_FPU|ITYPE_MMX|ITYPE_SSE|ITYPE_SSE2|ITYPE_SSE3))
+ {
+ // Check for prefixes that produce unpredictable results
+ for (i = 0; i < Instruction->PrefixCount; i++)
+ {
+ switch (Instruction->Prefixes[i])
+ {
+ case PREFIX_OPERAND_SIZE:
+ switch (Instruction->Type)
+ {
+ case ITYPE_FSTOREENV: case ITYPE_FLOADENV: case ITYPE_FSAVE: case ITYPE_FRESTORE: continue;
+ default: break;
+ }
+
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: operand size prefix used with FPU/MMX/SSEx\n", VIRTUAL_ADDRESS);
+ goto abort;
+ }
+ X86Instruction->HasOperandSizePrefix = FALSE;
+ if (X86Instruction->OperandSize == 2) X86Instruction->OperandSize = 2;
+ break;
+
+ case PREFIX_REPNE:
+ case PREFIX_REP:
+ if (Instruction->Groups & ITYPE_FPU) { assert(Instruction->Repeat); continue; }
+ // The Intel manual says this results in unpredictable behavior -- it's not even
+ // clear which SSE prefix is used as the third opcode byte in this case
+ // (e.g., is it the first or last SSE prefix?)
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: rep/repne used with MMX/SSEx\n", VIRTUAL_ADDRESS);
+ goto abort;
+
+ default:
+ break;
+ }
+ }
+ }
+
+ // Check for conflicts involving operand size
+ if (IS_AMD64())
+ {
+ // Check for use of rex.w=1 with an operand size prefix
+ if (X86Instruction->rex.w)
+ {
+ assert(X86Instruction->OperandSize == 8);
+ for (i = 0; i < Instruction->PrefixCount; i++)
+ {
+ if (Instruction->Prefixes[i] == PREFIX_OPERAND_SIZE)
+ {
+ X86Instruction->HasOperandSizePrefix = FALSE;
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: use of operand size prefix meaningless when REX.w=1\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ }
+ }
+ }
+
+ // Set default operand size to 64 instead of 32 for some instructions
+ switch (Instruction->Type)
+ {
+ case ITYPE_PUSH: case ITYPE_POP:
+ case ITYPE_PUSHF: case ITYPE_POPF:
+ case ITYPE_ENTER: case ITYPE_LEAVE:
+ case ITYPE_CALL: case ITYPE_BRANCH:
+ case ITYPE_LOOPCC: case ITYPE_RET:
+ X86Instruction->HasDefault64Operand = TRUE;
+ break;
+
+ case ITYPE_SYSTEM:
+ if (Instruction->OpcodeLength != 2) break;
+
+ // lgdt/lidt/lldt/ltr
+ if ((Instruction->LastOpcode == 0x00 || Instruction->LastOpcode == 0x01) &&
+ (OpcodeExtension == 0x02 || OpcodeExtension == 0x03))
+ {
+ X86Instruction->HasDefault64Operand = TRUE;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if (X86Instruction->HasDefault64Operand)
+ {
+ if (X86Instruction->rex.w)
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: use of REX.w is meaningless (default operand size is 64)\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->rex_b &= ~8;
+ X86Instruction->rex.w = 0;
+ }
+
+ if (X86Instruction->HasOperandSizePrefix)
+ {
+ assert(X86Instruction->OperandSize == 2);
+ X86Instruction->HasDefault64Operand = FALSE;
+ }
+ else
+ {
+ assert(X86Instruction->OperandSize >= 4);
+ X86Instruction->OperandSize = 8;
+ }
+ }
+ }
+
+ // Make sure rep/repe/repne is set correctly based on instruction
+ if (Instruction->Repeat)
+ {
+ switch (Instruction->Type)
+ {
+ case ITYPE_IN:
+ case ITYPE_OUT:
+ case ITYPE_STRMOV:
+ case ITYPE_STRSTOR:
+ case ITYPE_STRLOAD:
+ if (X86Instruction->HasRepeatWhileNotEqualPrefix)
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: REPNE should only be used with cmps/scas\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ // Treat it as just a "rep"
+ X86Instruction->HasRepeatWhileNotEqualPrefix = FALSE;
+ X86Instruction->HasRepeatWhileEqualPrefix = TRUE;
+ }
+ break;
+ case ITYPE_STRCMP:
+ break;
+ default:
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Repeat prefix used with non-string instruction\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ Instruction->Repeat = FALSE;
+ X86Instruction->HasRepeatWhileEqualPrefix = FALSE;
+ X86Instruction->HasRepeatWhileNotEqualPrefix = FALSE;
+ break;
+ }
+ }
+
+ if (Disassemble)
+ {
+ assert(!Instruction->StringIndex);
+ if (X86Instruction->HasRepeatWhileEqualPrefix)
+ {
+ if (Instruction->Type == ITYPE_STRCMP) { APPENDS("repe "); }
+ else { APPENDS("rep "); }
+ }
+ if (X86Instruction->HasRepeatWhileNotEqualPrefix) APPENDS("repne ");
+ if (X86Instruction->HasLockPrefix) APPENDS("lock ");
+ if (X86Instruction->HasBranchTakenPrefix) APPENDS("hinttake ");
+ if (X86Instruction->HasBranchNotTakenPrefix) APPENDS("hintskip ");
+ APPENDPAD(12);
+ APPEND(OPCSTR, SIZE_LEFT, "%s", X86Opcode->Mnemonic);
+ APPENDPAD(24);
+ }
+
+ if (Instruction->OperandCount)
+ {
+ Instruction->Operands[0].Flags = X86Opcode->OperandFlags[0] & X86_OPFLAGS_MASK;
+ Instruction->Operands[1].Flags = X86Opcode->OperandFlags[1] & X86_OPFLAGS_MASK;
+ Instruction->Operands[2].Flags = X86Opcode->OperandFlags[2] & X86_OPFLAGS_MASK;
+ Address = SetOperands(Instruction, Address, Flags);
+ if (!Address) goto abort;
+ assert(!(Instruction->Operands[0].Flags & 0x7F));
+ assert(!(Instruction->Operands[1].Flags & 0x7F));
+ assert(!(Instruction->Operands[2].Flags & 0x7F));
+ }
+
+ Disassembler->Stage2Count++;
+
+#ifdef TEST_DISASM
+ //////////////////////////////////////////////////////////////////////
+ // Test against other disassemblers
+ //////////////////////////////////////////////////////////////////////
+
+ if (IS_X86_32())
+ {
+ InstructionLength = X86_GetLength(Instruction, Instruction->Address);
+ if (InstructionLength && Instruction->Length != InstructionLength)
+ {
+ printf("[0x%08I64X] WARNING: instruction lengths differ (%d vs %d)\n", VIRTUAL_ADDRESS, Instruction->Length, InstructionLength);
+ DumpInstruction(Instruction, TRUE, TRUE);
+ assert(0);
+ }
+ }
+ else if (IS_AMD64())
+ {
+ // TODO: need other amd64 (x86-64) disassembler to test against
+ }
+ else if (IS_X86_16())
+ {
+ // TODO: need other x86 16-bit disassembler to test against
+ }
+#endif
+
+ //////////////////////////////////////////////////////////////////////
+ // Post-operand sanity checks
+ //////////////////////////////////////////////////////////////////////
+
+ if (!X86Instruction->HasDstAddressing && !X86Instruction->HasSrcAddressing)
+ {
+ if (X86Instruction->HasAddressSizePrefix)
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: address size prefix used with no addressing\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->HasAddressSizePrefix = FALSE;
+ }
+
+ if (X86Instruction->HasSegmentOverridePrefix)
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: segment override used with no addressing\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ }
+ }
+
+ // Detect use of unusual segments
+ if (!Instruction->AnomalyOccurred && !IS_X86_16())
+ {
+ switch (X86Instruction->Segment)
+ {
+ case SEG_CS: case SEG_DS: case SEG_SS:
+ break;
+ case SEG_ES:
+ switch (Instruction->Type)
+ {
+ case ITYPE_IN: case ITYPE_STRMOV: case ITYPE_STRCMP: case ITYPE_STRSTOR:
+ break;
+ default:
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: use of unexpected segment ES\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ break;
+ }
+ break;
+ case SEG_FS:
+ if (IS_X86_32() && !(Instruction->Groups & ITYPE_EXEC)) break;
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: use of unexpected segment FS\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ break;
+ case SEG_GS:
+ if (IS_AMD64() && !(Instruction->Groups & ITYPE_EXEC)) break;
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: use of unexpected segment GS\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ break;
+ default:
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: unexpected segment 0x%02X\n", VIRTUAL_ADDRESS, X86Instruction->Selector);
+ Instruction->AnomalyOccurred = TRUE;
+ break;
+ }
+ }
+
+ if ((X86Opcode->OperandFlags[0] & OP_COND_EXEC) == OP_COND_EXEC)
+ {
+ assert(Instruction->Type == ITYPE_BRANCHCC || Instruction->Type == ITYPE_LOOPCC);
+ for (i = 0; i < Instruction->PrefixCount; i++)
+ {
+ switch (Instruction->Prefixes[i])
+ {
+ case PREFIX_BRANCH_NOT_TAKEN:
+ if (!Instruction->AnomalyOccurred && X86Instruction->Segment != SEG_CS)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Segment override used with conditional branch\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ X86Instruction->Segment = SEG_CS;
+ X86Instruction->HasBranchNotTakenPrefix = TRUE;
+ break;
+ case PREFIX_BRANCH_TAKEN:
+ if (!Instruction->AnomalyOccurred && X86Instruction->Segment != SEG_DS)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Segment override used with conditional branch\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ X86Instruction->Segment = SEG_CS;
+ X86Instruction->HasBranchTakenPrefix = TRUE;
+ break;
+ }
+ }
+ }
+
+ //
+ // If lock prefix is enabled, verify it is valid
+ //
+ if (X86Instruction->HasLockPrefix &&
+ !IsValidLockPrefix(X86Instruction, Opcode, Instruction->OpcodeLength, Group, OpcodeExtension))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: Illegal use of lock prefix for instruction \"%s\"\n", VIRTUAL_ADDRESS, X86Opcode->Mnemonic);
+ goto abort;
+ }
+
+ //////////////////////////////////////////////////////////////////////
+ // Generate disassembly output
+ //////////////////////////////////////////////////////////////////////
+
+ if (Disassemble)
+ {
+ if ((Flags & DISASM_SHOWFLAGS) &&
+ (X86Instruction->Opcode.Preconditions || X86Instruction->Opcode.FlagsChanged || X86Instruction->Opcode.ResultsIfTrue))
+ {
+ APPENDPAD(124);
+ if (X86Instruction->Opcode.Preconditions)
+ {
+ Result = X86Instruction->Opcode.Preconditions;
+ APPENDS("COND:{ ");
+ if (Result & COND_L) APPENDS("L ");
+ if (Result & COND_NL) APPENDS("NL ");
+ if (Result & COND_LE) APPENDS("LE ");
+ if (Result & COND_NLE) APPENDS("NLE ");
+ if (Result & COND_G) APPENDS("G ");
+ if (Result & COND_NG) APPENDS("NG ");
+ if (Result & COND_GE) APPENDS("GE ");
+ if (Result & COND_NGE) APPENDS("NGE ");
+ if (Result & COND_A) APPENDS("A ");
+ if (Result & COND_NA) APPENDS("NA ");
+ if (Result & COND_AE) APPENDS("AE ");
+ if (Result & COND_NAE) APPENDS("NAE ");
+ if (Result & COND_B) APPENDS("B ");
+ if (Result & COND_NB) APPENDS("NB ");
+ if (Result & COND_BE) APPENDS("BE ");
+ if (Result & COND_NBE) APPENDS("NBE ");
+ if (Result & COND_E) APPENDS("E ");
+ if (Result & COND_NE) APPENDS("NE ");
+ if (Result & COND_C) APPENDS("C ");
+ if (Result & COND_NC) APPENDS("NC ");
+ if (Result & COND_Z) APPENDS("Z ");
+ if (Result & COND_NZ) APPENDS("NZ ");
+ if (Result & COND_P) APPENDS("P ");
+ if (Result & COND_NP) APPENDS("NP ");
+ if (Result & COND_PE) APPENDS("PE ");
+ if (Result & COND_PO) APPENDS("PO ");
+ if (Result & COND_O) APPENDS("O ");
+ if (Result & COND_NO) APPENDS("NO ");
+ if (Result & COND_U) APPENDS("U ");
+ if (Result & COND_NU) APPENDS("NU ");
+ if (Result & COND_S) APPENDS("S ");
+ if (Result & COND_NS) APPENDS("NS ");
+ if (Result & COND_D) APPENDS("D ");
+ APPENDB('}');
+ }
+
+ if (X86Instruction->Opcode.FlagsChanged)
+ {
+ Result = X86Instruction->Opcode.FlagsChanged;
+
+ if (Result & FLAG_SET_MASK)
+ {
+ APPENDS("SET:{ ");
+ if (Result & FLAG_CF_SET) APPENDS("C ");
+ if (Result & FLAG_DF_SET) APPENDS("D ");
+ if (Result & FLAG_IF_SET) APPENDS("I ");
+ APPENDB('}');
+ }
+
+ if (Result & FLAG_CLR_MASK)
+ {
+ APPENDS("CLR:{ ");
+ if (Result & FLAG_SF_CLR) APPENDS("S ");
+ if (Result & FLAG_ZF_CLR) APPENDS("Z ");
+ if (Result & FLAG_AF_CLR) APPENDS("A ");
+ if (Result & FLAG_CF_CLR) APPENDS("C ");
+ if (Result & FLAG_DF_CLR) APPENDS("D ");
+ if (Result & FLAG_IF_CLR) APPENDS("I ");
+ if (Result & FLAG_OF_CLR) APPENDS("O ");
+ if ((Result & FPU_ALL_CLR) == FPU_ALL_CLR)
+ {
+ APPENDS("FPU_ALL ");
+ }
+ else
+ {
+ if (Result & FPU_C0_CLR) APPENDS("FPU_C0 ");
+ if (Result & FPU_C1_CLR) APPENDS("FPU_C1 ");
+ if (Result & FPU_C2_CLR) APPENDS("FPU_C2 ");
+ if (Result & FPU_C3_CLR) APPENDS("FPU_C3 ");
+ }
+ APPENDB('}');
+ }
+
+ if ((Result & FLAG_MOD_MASK) == FLAG_MOD_MASK)
+ {
+ APPENDS("MOD:{ ");
+ if ((Result & FLAG_ALL_MOD) == FLAG_ALL_MOD)
+ {
+ APPENDS("FLAGS_ALL ");
+ }
+ else if ((Result & FLAG_COMMON_MOD) == FLAG_COMMON_MOD)
+ {
+ APPENDS("FLAGS_COMMON ");
+ }
+ else
+ {
+ if (Result & FLAG_OF_MOD) APPENDS("O ");
+ if (Result & FLAG_SF_MOD) APPENDS("S ");
+ if (Result & FLAG_ZF_MOD) APPENDS("Z ");
+ if (Result & FLAG_AF_MOD) APPENDS("A ");
+ if (Result & FLAG_PF_MOD) APPENDS("P ");
+ if (Result & FLAG_CF_MOD) APPENDS("C ");
+ if (Result & FLAG_DF_MOD) APPENDS("D ");
+ if (Result & FLAG_IF_MOD) APPENDS("I ");
+ }
+ if ((Result & FPU_ALL_MOD) == FPU_ALL_MOD)
+ {
+ APPENDS("FPU_ALL ");
+ }
+ else
+ {
+ if (Result & FPU_C0_MOD) APPENDS("FPU_C0 ");
+ if (Result & FPU_C1_MOD) APPENDS("FPU_C1 ");
+ if (Result & FPU_C2_MOD) APPENDS("FPU_C2 ");
+ if (Result & FPU_C3_MOD) APPENDS("FPU_C3 ");
+ }
+ APPENDB('}');
+ }
+
+ if (Result & FLAG_TOG_MASK)
+ {
+ APPENDS("TOG:{ ");
+ if (Result & FLAG_CF_TOG) APPENDS("C ");
+ APPENDB('}');
+ }
+ }
+ }
+
+ APPENDS("\n");
+ }
+ else
+ {
+ Instruction->String[0] = '\0';
+ }
+
+ if (!Instruction->Length || Instruction->Length > X86_MAX_INSTRUCTION_LEN)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: maximum instruction length reached (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+
+ if (!Decode)
+ {
+ Disassembler->Stage3CountNoDecode++;
+ return TRUE; // all work is done
+ }
+
+ //////////////////////////////////////////////////////////////////////
+ // Detect particularly interesting intructions
+ //////////////////////////////////////////////////////////////////////
+
+ Operand1 = &Instruction->Operands[0];
+ if (Instruction->Groups & ITYPE_EXEC)
+ {
+ // If it is a negative offset with a 1-byte or 2-byte offset, assume it is a loop
+ if (Operand1->Type == OPTYPE_OFFSET &&
+ Operand1->Length <= 2 && X86Instruction->Displacement < 0)
+ {
+ Instruction->CodeBranch.IsLoop = TRUE;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+
+ if (!Instruction->AnomalyOccurred &&
+ Operand1->TargetAddress >= (U64)Instruction->Address &&
+ Operand1->TargetAddress < (U64)Instruction->Address + Instruction->Length)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: branch into the middle of an instruction\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+
+ switch (Instruction->Type)
+ {
+ case ITYPE_BRANCH:
+ Operand1->Flags |= OP_ADDRESS;
+ assert(Instruction->OperandCount == 1);
+ if (!(Operand1->Flags & (OP_GLOBAL|OP_FAR)))
+ {
+ assert(!X86Instruction->HasSelector);
+ X86Instruction->Segment = SEG_CS;
+ }
+
+ if (Operand1->TargetAddress)
+ {
+ assert(!Instruction->CodeBranch.AddressOffset);
+ Instruction->CodeBranch.Count = 1;
+ Instruction->CodeBranch.Addresses[0] = Operand1->TargetAddress;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+ // If there is both a base and index register, the Result will probably be too wrong
+ // to even guess
+ else if (X86Instruction->HasFullDisplacement &&
+ ((X86Instruction->HasBaseRegister && !X86Instruction->HasIndexRegister) ||
+ (!X86Instruction->HasBaseRegister && X86Instruction->HasIndexRegister)))
+ {
+ assert(Operand1->Length <= 0xFF);
+ if (!X86Instruction->Scale)
+ {
+ if (Operand1->Length) X86Instruction->Scale = (U8)Operand1->Length;
+ else X86Instruction->Scale = X86Instruction->OperandSize;
+ }
+ assert(Operand1->Length <= 0xFF);
+ tmpScale = MAX(X86Instruction->Scale, Operand1->Length);
+
+ assert(tmpScale <= 16);
+ Instruction->CodeBranch.AddressOffset = (U8)tmpScale;
+ for (i = 0; i < MAX_CODE_REFERENCE_COUNT; i++) Instruction->CodeBranch.Addresses[i] = (U64)X86Instruction->Displacement + (i * tmpScale);
+ Instruction->CodeBranch.Count = i;
+ Instruction->CodeBranch.IsIndirect = TRUE;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+ break;
+
+ case ITYPE_CALL:
+ Instruction->Groups |= ITYPE_STACK;
+ Instruction->CodeBranch.IsCall = TRUE;
+ Operand1->Flags |= OP_ADDRESS;
+ assert(Instruction->OperandCount == 1);
+ if (!(Operand1->Flags & (OP_GLOBAL|OP_FAR)))
+ {
+ assert(!X86Instruction->HasSelector);
+ X86Instruction->Segment = SEG_CS;
+ }
+
+ if (Operand1->TargetAddress)
+ {
+ assert(!Instruction->CodeBranch.AddressOffset);
+ Instruction->CodeBranch.Count = 1;
+ Instruction->CodeBranch.Addresses[0] = Operand1->TargetAddress;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+ // If there is both a base and index register, the Result will probably be too wrong
+ // to even guess
+ else if (X86Instruction->HasFullDisplacement &&
+ ((X86Instruction->HasBaseRegister && !X86Instruction->HasIndexRegister) ||
+ (!X86Instruction->HasBaseRegister && X86Instruction->HasIndexRegister)))
+ {
+ //DISASM_OUTPUT(("[0x%08I64X] Scale %d, displacement 0x%08I64x\n", VIRTUAL_ADDRESS, X86Instruction->Scale, X86Instruction->Displacement));
+ if (!X86Instruction->Scale)
+ {
+ assert(Operand1->Length <= 0xFF);
+ if (Operand1->Length) X86Instruction->Scale = (U8)Operand1->Length;
+ else X86Instruction->Scale = X86Instruction->OperandSize;
+ }
+ tmpScale = MAX(X86Instruction->Scale, Operand1->Length);
+
+ assert(tmpScale <= 16);
+ Instruction->CodeBranch.AddressOffset = (U8)tmpScale;
+ assert(X86Instruction->Scale > 1);
+ for (i = 0; i < MAX_CODE_REFERENCE_COUNT; i++) Instruction->CodeBranch.Addresses[i] = (U64)X86Instruction->Displacement + (i * tmpScale);
+ Instruction->CodeBranch.Count = i;
+ Instruction->CodeBranch.IsIndirect = TRUE;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+ break;
+
+ case ITYPE_BRANCHCC:
+ assert(Instruction->OperandCount == 1);
+ assert(Operand1->Flags & OP_ADDRESS);
+ assert(Operand1->Type == OPTYPE_OFFSET);
+ if (!(Operand1->Flags & (OP_GLOBAL|OP_FAR)))
+ {
+ assert(!X86Instruction->HasSelector);
+ X86Instruction->Segment = SEG_CS;
+ }
+
+ if (Operand1->TargetAddress)
+ {
+ assert(!Instruction->CodeBranch.AddressOffset);
+ Instruction->CodeBranch.Count = 2;
+ Instruction->CodeBranch.Addresses[0] = Operand1->TargetAddress;
+ Instruction->CodeBranch.Addresses[1] = (U64)Instruction->Address + Instruction->Length;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+ break;
+
+ case ITYPE_LOOPCC:
+ Instruction->CodeBranch.IsLoop = TRUE;
+ assert(Instruction->OperandCount == 1);
+ assert(Operand1->Flags & OP_ADDRESS);
+ assert(Operand1->Type == OPTYPE_OFFSET);
+ assert(!(Operand1->Flags & (OP_GLOBAL|OP_FAR)));
+ if (Operand1->TargetAddress)
+ {
+ assert(!Instruction->CodeBranch.AddressOffset);
+ Instruction->CodeBranch.Count = 2;
+ Instruction->CodeBranch.Addresses[0] = Operand1->TargetAddress;
+ Instruction->CodeBranch.Addresses[1] = (U64)Instruction->Address + Instruction->Length;
+ Instruction->CodeBranch.Operand = Operand1;
+ }
+ break;
+
+ case ITYPE_RET:
+ Instruction->Groups |= ITYPE_STACK;
+ break;
+
+ default:
+ break; // do nothing
+ }
+ }
+ else // possible data instruction
+ {
+ for (i = 0, Operand = Instruction->Operands; i < Instruction->OperandCount; i++, Operand++)
+ {
+ if (Operand->TargetAddress)
+ {
+ if (Operand->Flags & OP_DST)
+ {
+ assert(!Instruction->DataDst.Count);
+ Instruction->DataDst.Count = 1;
+ Instruction->DataDst.Addresses[0] = Operand->TargetAddress;
+ Instruction->DataDst.DataSize = Operand->Length;
+ Instruction->DataDst.Operand = Operand;
+ DISASM_OUTPUT(("[0x%08I64X] Write of size %d to 0x%04I64X\n", VIRTUAL_ADDRESS, Operand->Length, Operand->TargetAddress));
+ }
+ if (Operand->Flags & OP_SRC)
+ {
+ assert(!Instruction->DataSrc.Count);
+ Instruction->DataSrc.Count = 1;
+ Instruction->DataSrc.Addresses[0] = Operand->TargetAddress;
+ Instruction->DataSrc.DataSize = Operand->Length;
+ Instruction->DataSrc.Operand = Operand;
+ DISASM_OUTPUT(("[0x%08I64X] Read of size %d to 0x%04I64X\n", VIRTUAL_ADDRESS, Operand->Length, Operand->TargetAddress));
+ }
+ }
+
+ // If there is both a base and index register, the Result will probably be too wrong
+ // to even guess
+ else if (Operand->Flags & OP_GLOBAL &&
+ ((X86Instruction->HasBaseRegister && !X86Instruction->HasIndexRegister) ||
+ (!X86Instruction->HasBaseRegister && X86Instruction->HasIndexRegister)))
+ {
+ DISASM_OUTPUT(("[0x%08I64X] Data reference (scale %d, size %d, displacement 0x%08I64x)\n", VIRTUAL_ADDRESS, X86Instruction->Scale, Operand->Length, X86Instruction->Displacement));
+ if (!X86Instruction->Scale)
+ {
+ assert(Operand->Length <= 0xFF);
+ if (Operand->Length) X86Instruction->Scale = (U8)Operand->Length;
+ else X86Instruction->Scale = X86Instruction->OperandSize;
+ }
+ tmpScale = MAX(X86Instruction->Scale, Operand->Length);
+
+ assert(X86Instruction->HasFullDisplacement);
+ if (Operand->Flags & OP_DST)
+ {
+ assert(!Instruction->DataDst.Count);
+ assert(tmpScale <= 16);
+ Instruction->CodeBranch.AddressOffset = (U8)tmpScale;
+ for (i = 0; i < MAX_DATA_REFERENCE_COUNT; i++) Instruction->DataDst.Addresses[i] = (U64)X86Instruction->Displacement + (i * tmpScale);
+ Instruction->DataDst.Count = i;
+ Instruction->DataDst.DataSize = Operand->Length;
+ Instruction->DataDst.Operand = Operand;
+ }
+ if (Operand->Flags & OP_SRC)
+ {
+ assert(!Instruction->DataSrc.Count);
+ assert(tmpScale <= 16);
+ Instruction->CodeBranch.AddressOffset = (U8)tmpScale;
+ for (i = 0; i < MAX_DATA_REFERENCE_COUNT; i++) Instruction->DataSrc.Addresses[i] = (U64)X86Instruction->Displacement + (i * tmpScale);
+ Instruction->DataSrc.Count = i;
+ Instruction->DataSrc.DataSize = Operand->Length;
+ Instruction->DataSrc.Operand = Operand;
+ }
+ }
+ }
+ }
+
+ if (Instruction->Groups & ITYPE_STACK)
+ {
+ switch (Instruction->Type)
+ {
+ case ITYPE_PUSH:
+ assert(Instruction->OperandCount == 1 && Operand1->Length);
+ Instruction->StackChange = -Operand1->Length;
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_POP:
+ assert(Instruction->OperandCount == 1 && Operand1->Length);
+ Instruction->StackChange = Operand1->Length;
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_PUSHA:
+ Instruction->StackChange = -(X86Instruction->OperandSize * 8); // xAX, xCX, xDX, xBX, xBP, xSP, xSI, xDI
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_POPA:
+ Instruction->StackChange = X86Instruction->OperandSize * 8; // xDI, xSI, xSP, xBP, xBX, xDX, xCX, xAX
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_PUSHF:
+ Instruction->StackChange = -Operand1->Length;
+ Instruction->NeedsEmulation = TRUE;
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_POPF:
+ Instruction->StackChange = Operand1->Length;
+ Instruction->NeedsEmulation = TRUE;
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_ENTER:
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (Instruction->Operands[1].Value_U64 & 3)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: ENTER has invalid operand 2\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ if (Instruction->Operands[2].Value_U64 & ~0x1F)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: ENTER has invalid operand 3\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ }
+ SANITY_CHECK_ADDRESS_SIZE();
+ Instruction->Operands[2].Value_U64 &= 0x1F;
+
+ // frame pointer + stack space
+ i = Operand1->Length + (U32)Instruction->Operands[1].Value_U64;
+ Instruction->StackChange = -((LONG)i);
+ i = (U32)Instruction->Operands[2].Value_U64 * Operand1->Length;
+ Instruction->StackChange -= i;
+ break;
+
+ case ITYPE_LEAVE:
+ // This will do "mov esp, ebp; pop ebp" so the StackChange size is dynamic
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_CALL:
+ Instruction->StackChange = -X86Instruction->OperandSize;
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_RET:
+ Instruction->StackChange = X86Instruction->OperandSize;
+
+ switch (Opcode)
+ {
+ case 0xC3: // ret with no args
+ break;
+
+ case 0xC2: // ret with 1 arg
+ if (!Instruction->AnomalyOccurred && (Operand1->Value_U64 & 3))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: ret has invalid operand 1\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ Instruction->StackChange += (LONG)Operand1->Value_U64;
+ break;
+
+ case 0xCB: // far ret with no args
+ Instruction->StackChange *= 2; // account for segment
+ Instruction->StackChange += (LONG)Operand1->Value_U64;
+ break;
+
+ case 0xCA: // far ret with 1 arg
+ if (!Instruction->AnomalyOccurred && (Operand1->Value_U64 & 3))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: retf has invalid operand 1\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ Instruction->StackChange *= 2; // account for segment
+ Instruction->StackChange += (LONG)Operand1->Value_U64;
+ break;
+ }
+ SANITY_CHECK_ADDRESS_SIZE();
+ break;
+
+ case ITYPE_ADD:
+ case ITYPE_XCHGADD:
+ if (Instruction->Operands[1].Value_S64) Instruction->StackChange = (LONG)(Instruction->Operands[1].Value_S64);
+ break;
+ case ITYPE_SUB:
+ if (Instruction->Operands[1].Value_S64) Instruction->StackChange = (LONG)(-Instruction->Operands[1].Value_S64);
+ break;
+ case ITYPE_MOV:
+ case ITYPE_AND:
+ break;
+
+ default:
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Instruction \"%s\" is modifying the stack\n", VIRTUAL_ADDRESS, X86Opcode->Mnemonic);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ break;
+ }
+
+ if (!Instruction->AnomalyOccurred &&
+ ((X86Instruction->OperandSize != 2 && (Instruction->StackChange & 3)) || (Instruction->StackChange & 1)))
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: \"%s\" has invalid stack change 0x%02X\n", VIRTUAL_ADDRESS, X86Opcode->Mnemonic, Instruction->StackChange);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ }
+
+ if (Instruction->Groups & ITYPE_TRAPS)
+ {
+ switch (Instruction->Type)
+ {
+ case ITYPE_TRAP:
+ case ITYPE_TRAPCC:
+ case ITYPE_TRAPRET:
+ case ITYPE_BOUNDS:
+ case ITYPE_DEBUG:
+ case ITYPE_TRACE:
+ case ITYPE_INVALID:
+ case ITYPE_OFLOW:
+ Instruction->NeedsEmulation = TRUE;
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ }
+
+ if (Instruction->Groups & ITYPE_SYSTEM)
+ {
+ switch (Instruction->Type)
+ {
+ case ITYPE_CPUID:
+ case ITYPE_SYSCALL:
+ case ITYPE_SYSCALLRET:
+ // This doesn't require privileges
+ break;
+
+ case ITYPE_HALT:
+ case ITYPE_IN:
+ case ITYPE_OUT:
+ default:
+ Instruction->NeedsEmulation = TRUE;
+ break;
+ }
+ }
+
+ Disassembler->Stage3CountWithDecode++;
+ return TRUE;
+
+abort:
+ if (!SuppressErrors)
+ {
+#ifdef TEST_DISASM
+ printf("Dump of 0x%04I64X:\n", VIRTUAL_ADDRESS);
+ __try { DumpAsBytes(stdout, Instruction->Address, (ULONG_PTR)VIRTUAL_ADDRESS, 16, TRUE); }
+ __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {}
+#endif
+ fflush(stdout);
+ }
+ return FALSE;
+}
+
+// Address = address to first byte after the opcode (e.g., first byte of ModR/M byte or
+// immediate value
+//
+// Returns the address immediately following the operand (e.g., the next operand or the
+// start of the next instruction
+INTERNAL U8 *SetOperands(INSTRUCTION *Instruction, U8 *Address, U32 Flags)
+{
+ INSTRUCTION_OPERAND *Operand;
+ U32 Index, OperandIndex;
+ S64 Displacement = 0;
+ U8 Register;
+ U32 OperandFlags, OperandType, AddressMode, Segment;
+ U8 Opcode;
+ MODRM modrm;
+ REX rex;
+ REX_MODRM rex_modrm;
+ X86_OPCODE *X86Opcode;
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+ BOOL Decode = Flags & DISASM_DECODE;
+ BOOL Disassemble = Flags & DISASM_DISASSEMBLE;
+ BOOL SuppressErrors = Flags & DISASM_SUPPRESSERRORS;
+
+ Opcode = Instruction->LastOpcode;
+ X86Opcode = &X86Instruction->Opcode;
+
+ // Setup Mod R/M byte
+ if (X86Instruction->HasModRM)
+ {
+ SET_MODRM(X86Instruction->modrm, X86Instruction->modrm_b);
+ modrm = X86Instruction->modrm;
+ rex = X86Instruction->rex;
+ SET_REX_MODRM(X86Instruction->rex_modrm, rex, modrm);
+ rex_modrm = X86Instruction->rex_modrm;
+ //DISASM_OUTPUT(("[0x%08I64X] ModRM = 0x%02X (mod=%d, reg=%d, rm=%d)\n", VIRTUAL_ADDRESS, X86Instruction->modrm_b, modrm.mod, rex_modrm.reg, rex_modrm.rm));
+ INSTR_INC(1); // increment Instruction->Length and address
+ }
+ else
+ {
+ // initialize them to 0
+ modrm = X86Instruction->modrm;
+ rex = X86Instruction->rex;
+ rex_modrm = X86Instruction->rex_modrm;
+ }
+
+ for (OperandIndex = 0; OperandIndex < Instruction->OperandCount; OperandIndex++)
+ {
+ Operand = &Instruction->Operands[OperandIndex];
+ assert(!(Operand->Flags & 0x7F));
+
+ OperandFlags = X86Opcode->OperandFlags[OperandIndex] & X86_OPFLAGS_MASK;
+ OperandType = X86Opcode->OperandFlags[OperandIndex] & X86_OPTYPE_MASK;
+ AddressMode = X86Opcode->OperandFlags[OperandIndex] & X86_AMODE_MASK;
+ if (Decode && OperandIndex != 0) APPENDS(", ");
+
+ switch (OperandType)
+ {
+ ////////////////////////////////////////////////////////////
+ // Special operand types with no associated addressing mode
+ ////////////////////////////////////////////////////////////
+
+ case OPTYPE_0:
+ if (!Decode) continue;
+ Operand->Value_U64 = 0;
+ Operand->Type = OPTYPE_IMM;
+ //DISASM_OUTPUT(("[SetOperand] const 0\n"));
+ if (Disassemble)
+ {
+ APPENDS("<0>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_1:
+ if (!Decode) continue;
+ Operand->Value_U64 = 1;
+ Operand->Type = OPTYPE_IMM;
+ //DISASM_OUTPUT(("[SetOperand] const 1\n"));
+ if (Disassemble)
+ {
+ APPENDS("<1>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FF:
+ if (!Decode) continue;
+ Operand->Value_U64 = 0xFF;
+ Operand->Type = OPTYPE_IMM;
+ //DISASM_OUTPUT(("[SetOperand] const 0xff\n"));
+ if (Disassemble)
+ {
+ APPENDS("<0xFF>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_TSC:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] TSC\n"));
+ if (Disassemble)
+ {
+ APPENDS("<TSC_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_CS_MSR:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] CS MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<CS_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_EIP_MSR:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] EIP MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<EIP_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_ESP_MSR:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] ESP MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<ESP_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_KERNELBASE_MSR:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] KernelBase MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<KRNLBASE_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_STAR_MSR:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] KernelBase MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<STAR_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_CSTAR_MSR:
+ assert(!IS_AMD64());
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] CSTAR MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<CSTAR_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_LSTAR_MSR:
+ assert(IS_AMD64());
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] LSTAR MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<LSTAR_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FMASK_MSR:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_SPECIAL;
+ //DISASM_OUTPUT(("[SetOperand] FMASK MSR\n"));
+ if (Disassemble)
+ {
+ APPENDS("<FMASK_MSR>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OP_REG:
+ if (!Decode) continue;
+ // The reg field is included in the opcode
+ Operand->Length = X86Instruction->OperandSize;
+ Register = X86_GET_REG64(Opcode);
+ switch (X86Instruction->OperandSize)
+ {
+ case 8:
+ Operand->Register = AMD64_64BIT_OFFSET + Register;
+ break;
+ case 4:
+ Operand->Register = X86_32BIT_OFFSET + Register;
+ CHECK_AMD64_REG();
+ break;
+ case 2:
+ Operand->Register = X86_16BIT_OFFSET + Register;
+ CHECK_AMD64_REG();
+ break;
+ case 1:
+ Operand->Register = X86_8BIT_OFFSET + Register;
+ if (X86Instruction->rex_b) CHECK_AMD64_REG();
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+ X86_SET_REG(Register);
+
+ //DISASM_OUTPUT(("[SetOperand] OP_REG %s\n", X86_Registers[Operand->Register]));
+ if (Disassemble)
+ {
+ APPENDB('<'); APPENDS(X86_Registers[Operand->Register]); APPENDB('>');
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_REG8:
+ if (!Decode) continue;
+ // The reg field is included in the opcode
+ Operand->Length = 1;
+ Register = X86_GET_REG64(Opcode);
+ Operand->Register = X86_8BIT_OFFSET + Register;
+ CHECK_AMD64_REG();
+ X86_SET_REG(Register);
+
+ //DISASM_OUTPUT(("[SetOperand] OP_REG %s\n", X86_Registers[Operand->Register]));
+ if (Disassemble)
+ {
+ APPENDB('<'); APPENDS(X86_Registers[Operand->Register]); APPENDB('>');
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_REG_AL:
+ if (!Decode) continue;
+ Operand->Length = 1;
+ Operand->Register = X86_REG_AL;
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] reg AL\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_REG_CL:
+ if (!Decode) continue;
+ Operand->Length = 1;
+ Operand->Register = X86_REG_CL;
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] reg CL\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_REG_AH:
+ if (!Decode) continue;
+ Operand->Length = 1;
+ Operand->Register = X86_REG_AH;
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] reg AH\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_REG_AX:
+ if (!Decode) continue;
+ Operand->Length = 2;
+ Operand->Register = X86_REG_AX;
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] reg AX\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_REG_DX:
+ if (!Decode) continue;
+ Operand->Length = 2;
+ Operand->Register = X86_REG_DX;
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] reg DX\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_REG_ECX:
+ if (!Decode) continue;
+ Operand->Length = 4;
+ Operand->Register = X86_REG_ECX;
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] reg ECX\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_REG_xBP:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RBP; break;
+ case 4: Operand->Register = X86_REG_EBP; break;
+ case 2: Operand->Register = X86_REG_BP; break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] xAX_BIG (size = %d)\n", Operand->Length));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_REG_xAX_BIG:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RAX; break;
+ case 4: Operand->Register = X86_REG_EAX; break;
+ case 2: Operand->Register = X86_REG_AX; break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] xAX_BIG (size = %d)\n", Operand->Length));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_REG_xAX_SMALL:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize >> 1;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Register = X86_REG_EAX; break;
+ case 4: Operand->Register = X86_REG_AX; break;
+ case 2: Operand->Register = X86_REG_AL; break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_REG(0);
+ //DISASM_OUTPUT(("[SetOperand] xAX_SMALL (size = %d)\n", Operand->Length));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_xCX_HI_xBX_LO:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize << 1;
+ if (Disassemble)
+ {
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: APPENDS("<RCX:RBX>"); break;
+ case 4: APPENDS("<ECX:EBX>"); break;
+ case 2: APPENDS("<CX:BX>"); break;
+ default: assert(0); return NULL;
+ }
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] xCX_BIG:xBX_BIG (size = %d)\n", Operand->Length));
+ continue;
+ case OPTYPE_xDX_HI_xAX_LO:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize << 1;
+ if (Disassemble)
+ {
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: APPENDS("<RDX:RAX>"); break;
+ case 4: APPENDS("<EDX:EAX>"); break;
+ case 2: APPENDS("<DX:AX>"); break;
+ default: assert(0); return NULL;
+ }
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] xDX_BIG:xAX_BIG (size = %d)\n", Operand->Length));
+ continue;
+
+ case OPTYPE_EDX_HI_EAX_LO:
+ if (!Decode) continue;
+ Operand->Length = 8;
+ //DISASM_OUTPUT(("[SetOperand] EDX:EAX\n"));
+ if (Disassemble)
+ {
+ APPENDS("<EDX:EAX>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_EDX_ECX_EBX_EAX:
+ Operand->Length = 32;
+ //DISASM_OUTPUT(("[SetOperand] EDX:ECX:EBX:EAX\n"));
+ if (Disassemble)
+ {
+ APPENDS("<EDX:ECX:EBX:EAX>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_FLAGS:
+ if (!Decode) continue;
+ Operand->Length = 2;
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_REG_FLAGS;
+ //DISASM_OUTPUT(("[SetOperand] reg FLAGS\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_xFLAGS:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize;
+ Operand->Flags |= OP_REG;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RFLAGS; break;
+ case 4: Operand->Register = X86_REG_EFLAGS; break;
+ case 2: Operand->Register = X86_REG_FLAGS; break;
+ default: assert(0); return NULL;
+ }
+ //DISASM_OUTPUT(("[SetOperand] reg xFLAGS (size = %d)\n", Operand->Length));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_CS:
+ if (!Decode) continue;
+ if (Instruction->Type != ITYPE_PUSH && Instruction->Type != ITYPE_POP) Operand->Length = 2;
+ else Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_SEG_CS;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] seg CS\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_DS:
+ if (!Decode) continue;
+ if (Instruction->Type != ITYPE_PUSH && Instruction->Type != ITYPE_POP) Operand->Length = 2;
+ else Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_SEG_DS;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] seg DS\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_ES:
+ if (!Decode) continue;
+ if (Instruction->Type != ITYPE_PUSH && Instruction->Type != ITYPE_POP) Operand->Length = 2;
+ else Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_SEG_ES;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] seg ES\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FS:
+ if (!Decode) continue;
+ if (Instruction->Type != ITYPE_PUSH && Instruction->Type != ITYPE_POP) Operand->Length = 2;
+ else Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_SEG_FS;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] seg FS\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_GS:
+ if (!Decode) continue;
+ if (Instruction->Type != ITYPE_PUSH && Instruction->Type != ITYPE_POP) Operand->Length = 2;
+ else Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_SEG_GS;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] seg GS\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_SS:
+ if (!Decode) continue;
+ if (Instruction->Type != ITYPE_PUSH && Instruction->Type != ITYPE_POP) Operand->Length = 2;
+ else Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_SEG_SS;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] seg SS\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_CR0:
+ if (!Decode) continue;
+ Operand->Length = X86Instruction->OperandSize;
+ Operand->Register = X86_REG_CR0;
+ Operand->Flags |= OP_REG;
+ //DISASM_OUTPUT(("[SetOperand] reg CR0\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_STx:
+ if (!Decode) continue;
+ Operand->Length = 10;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Flags |= OP_REG;
+ Register = X86_GET_REG(X86Instruction->modrm_b);
+ Operand->Register = X86_FPU_OFFSET + Register;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_STx: reg st(%d)\n", Register));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_ST0:
+ if (!Decode) continue;
+ Operand->Length = 10;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_REG_ST0;
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_ST1:
+ if (!Decode) continue;
+ Operand->Length = 10;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_REG_ST1;
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "<%s>", X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_FPU_STATUS:
+ if (!Decode) continue;
+ Operand->Length = 2;
+ if (Disassemble)
+ {
+ APPENDS("<FPUSTAT>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_FPU_CONTROL:
+ if (!Decode) continue;
+ Operand->Length = 2;
+ if (Disassemble)
+ {
+ APPENDS("<FPUCTRL>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_FPU_TAG:
+ if (!Decode) continue;
+ Operand->Length = 2;
+ if (Disassemble)
+ {
+ APPENDS("<FPUTAG>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case OPTYPE_FLDZ:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<0.0>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FLD1:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<1.0>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FLDPI:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<pi>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FLDL2T:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<log_2 10>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FLDL2E:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<log_2 e>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FLDLG2:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<log_10 2>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+ case OPTYPE_FLDLN2:
+ if (!Decode) continue;
+ Operand->Type = OPTYPE_FLOAT;
+ Operand->Length = 10;
+ if (Disassemble)
+ {
+ APPENDS("<ln 2>");
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ ////////////////////////////////////////////////////////////
+ // Fixed sizes regardless of operand size
+ ////////////////////////////////////////////////////////////
+
+ case OPTYPE_b: // byte regardless of operand size
+ Operand->Length = 1;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_b (size 1, signed %d)\n", ((OperandFlags & OP_SIGNED) != 0)));
+ break;
+
+ case OPTYPE_w: // word regardless of operand size
+ Operand->Length = 2;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_w (size 2)\n"));
+ break;
+
+ case OPTYPE_d: // dword regardless of operand size
+ Operand->Length = 4;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_d (size 4)\n"));
+ break;
+
+ case OPTYPE_q: // qword regardless of operand size
+ Operand->Length = 8;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_q (size 8)\n"));
+ break;
+
+ case OPTYPE_o: // oword regardless of operand size
+ Operand->Length = 16;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_o (size 16)\n"));
+ break;
+
+ case OPTYPE_dt: // 6-byte or 10-byte pseudo descriptor (sgdt, lgdt, sidt, lidt)
+ if (IS_AMD64()) Operand->Length = 10;
+ else Operand->Length = 6;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_dt (%d bytes)\n", Operand->Length));
+ break;
+
+ case OPTYPE_cpu:
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Undocumented loadall instruction?\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ Operand->Length = 204;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_cpu (size 204)\n"));
+ break;
+
+ ////////////////////////////////////////////////////////////
+ // Sizes depending on the operand size
+ ////////////////////////////////////////////////////////////
+
+ case OPTYPE_z: // word if operand size is 16 bits and dword otherwise
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: case 4: Operand->Length = 4; break;
+ case 2: Operand->Length = 2; break;
+ default: assert(0); return NULL;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_z (length %d)\n", Operand->Length));
+ break;
+
+ case OPTYPE_v: // word, dword, or qword
+ Operand->Length = X86Instruction->OperandSize;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_v (size %d, signed = %d)\n", Operand->Length, ((OperandFlags & OP_SIGNED) != 0)));
+ break;
+
+ case OPTYPE_a: // two word or dword operands in memory (used only by bound)
+ assert(Instruction->OpcodeBytes[0] == X86_BOUND);
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: case 4: Operand->Length = 8; break;
+ case 2: Operand->Length = 4; break;
+ default: assert(0); return NULL;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_a (size %d)\n", Operand->Length));
+ break;
+
+ case OPTYPE_p: // 32-bit or 48-bit pointer depending on operand size
+ if (!Instruction->AnomalyOccurred && X86Instruction->HasSegmentOverridePrefix)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Segment override used when segment is explicit\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: case 4: Operand->Length = 6; break;
+ case 2: Operand->Length = 4; break;
+ default: assert(0); return NULL;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_p (length %d)\n", Operand->Length));
+ break;
+
+ case OPTYPE_dq: // dword or qword
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_dq (size 4 or 8)\n"));
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Length = 8; break;
+ case 4: case 2: Operand->Length = 4; break;
+ default: assert(0); return NULL;
+ }
+ break;
+
+ case OPTYPE_mw: // a word if the destination operand is memory
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_mw (size 0)\n"));
+ assert(X86Instruction->HasModRM);
+ if (modrm.mod == 3) Operand->Length = X86Instruction->OperandSize; // using register
+ else Operand->Length = 2; // using memory
+ break;
+
+ case OPTYPE_lea:
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_lea (size 0)\n"));
+ assert(OperandIndex == 1);
+ Operand->Length = Instruction->Operands[0].Length;
+ break;
+
+ ////////////////////////////////////////////////////////////
+ // FPU types
+ ////////////////////////////////////////////////////////////
+
+ case OPTYPE_ps: // packed single real
+ Operand->Length = 4;
+ Operand->Type = OPTYPE_FLOAT;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_ps (packed single real)\n"));
+ break;
+ case OPTYPE_pd: // packed double real
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_FLOAT;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_pd (packed double real)\n"));
+ break;
+ case OPTYPE_pb: // packed BCD
+ Operand->Length = 10;
+ Operand->Type = OPTYPE_BCD;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_pb (packed BCD)\n"));
+ break;
+ case OPTYPE_ss: // scalar single real
+ Operand->Length = 4;
+ Operand->Type = OPTYPE_FLOAT;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_ss (single real)\n"));
+ break;
+ case OPTYPE_sd: // scalar double real
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_FLOAT;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_sd (double real)\n"));
+ break;
+ case OPTYPE_se: // extended real
+ Operand->Length = 10;
+ Operand->Type = OPTYPE_FLOAT;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_se (extended real)\n"));
+ break;
+
+ case OPTYPE_fev: // FPU environment (28 bytes in 32-bit modes, 14 bytes in 16-bit real mode)
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: case 4: Operand->Length = 28; break;
+ case 2: Operand->Length = 14; break;
+ default: assert(0); return NULL;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_fev (FPU environment, length %d)\n", Operand->Length));
+ break;
+
+ case OPTYPE_fst1: // FPU state (108 bytes in 32-bit modes, 94 bytes in 16-bit real mode)
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: case 4: Operand->Length = 108; break;
+ case 2: Operand->Length = 94; break;
+ default: assert(0); return NULL;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_fst1 (FPU state, length %d)\n", Operand->Length));
+ break;
+
+ case OPTYPE_fst2: // 512 bytes for FPU state (FPU + MMX + XXM + MXCSR)
+ Operand->Length = 512;
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_fst2 (FPU + MMX + XXM + MXCSR state, length 512)\n"));
+ break;
+
+ case OPTYPE_sso:
+ if (modrm.mod == 3) // from register
+ {
+ Operand->Length = 16;
+ }
+ else // from memory
+ {
+ Operand->Length = 4;
+ Operand->Type = OPTYPE_FLOAT;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_sso (single real or oword)\n"));
+ break;
+
+ case OPTYPE_sdo:
+ if (modrm.mod == 3) // from register
+ {
+ Operand->Length = 16;
+ }
+ else // from memory
+ {
+ Operand->Length = 8;
+ Operand->Type = OPTYPE_FLOAT;
+ }
+ //DISASM_OUTPUT(("[SetOperand] OPTYPE_sso (double real or oword)\n"));
+ break;
+
+ default:
+ assert(0);
+ return NULL;
+ }
+
+ switch (AddressMode)
+ {
+ ////////////////////////////////////////////////////////////
+ // Special types
+ ////////////////////////////////////////////////////////////
+
+ case AMODE_xlat: // DS:[EBX+AL]
+ if (!Decode) continue;
+ assert(Operand->Length == 1);
+ Operand->Flags |= OP_ADDRESS | OP_REG;
+ Operand->Type = OPTYPE_STRING;
+
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RBX; break;
+ case 4: Operand->Register = X86_REG_EBX; break;
+ case 2: Operand->Register = X86_REG_BX; break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_ADDR();
+ X86Instruction->Scale = 1;
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ X86Instruction->IndexRegister = X86_REG_AL;
+ X86Instruction->HasIndexRegister = TRUE;
+
+ //DISASM_OUTPUT(("[SetOperand] AMODE_xlat (DS:[EBX+AL])\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "%s:[%s]",
+ Segments[X86Instruction->Segment], X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ ////////////////////////////////////////////////////////////
+ // Without mod R/M byte
+ ////////////////////////////////////////////////////////////
+
+ case AMODE_I: // immediate value
+ if (Decode)
+ {
+ Operand->Type = OPTYPE_IMM;
+ switch (Operand->Length)
+ {
+ case 8:
+ if (OperandFlags & OP_SIGNED) Operand->Value_S64 = (S64)*((S64 *)Address);
+ else Operand->Value_U64 = (U64)*((U64 *)Address);
+ break;
+ case 4:
+ if (!(OperandFlags & OP_SIGNED) && OperandIndex == 1 &&
+ (Instruction->Operands[0].Flags & (OP_REG|OP_ADDRESS)) &&
+ Instruction->Operands[0].Length == 8)
+ {
+ // For some opcodes the second operand is a sign-extended imm32 value
+ assert(X86Instruction->OperandSize == 8);
+ switch (Instruction->Type)
+ {
+ case ITYPE_AND:
+ case ITYPE_ADD:
+ case ITYPE_XCHGADD:
+ case ITYPE_CMP:
+ case ITYPE_MOV:
+ case ITYPE_SUB:
+ case ITYPE_TEST:
+ case ITYPE_OR:
+ case ITYPE_XOR:
+ assert(OperandIndex == 1);
+ Operand->Value_S64 = (S64)*((S32 *)Address);
+ break;
+ default:
+ assert(0);
+ if (OperandFlags & OP_SIGNED) Operand->Value_S64 = (S64)*((S32 *)Address);
+ else Operand->Value_U64 = (U64)*((U32 *)Address);
+ break;
+ }
+ }
+ else
+ {
+ if (OperandFlags & OP_SIGNED) Operand->Value_S64 = (S64)*((S32 *)Address);
+ else Operand->Value_U64 = (U64)*((U32 *)Address);
+ }
+ break;
+ case 2:
+ if (OperandFlags & OP_SIGNED) Operand->Value_S64 = (S64)*((S16 *)Address);
+ else Operand->Value_U64 = (U64)*((U16 *)Address);
+ break;
+ case 1:
+ if (OperandFlags & OP_SIGNED) Operand->Value_S64 = (S64)*((S8 *)Address);
+ else Operand->Value_U64 = (U64)*((U8 *)Address);
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+ }
+ INSTR_INC(Operand->Length); // increment Instruction->Length and address
+ assert(X86Instruction->OperandSize >= Operand->Length);
+ if (Instruction->Type == ITYPE_PUSH) Operand->Length = X86Instruction->OperandSize;
+
+ //DISASM_OUTPUT(("[SetOperand] AMODE_I (immediate data)\n"));
+ if (Disassemble)
+ {
+ X86_WRITE_IMMEDIATE();
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case AMODE_J: // IP-relative jump offset
+ SANITY_CHECK_ADDRESS_SIZE();
+ if (Decode)
+ {
+ Operand->Flags |= OP_IPREL | OP_SIGNED | OP_REG | OP_ADDRESS;
+ Operand->Type = OPTYPE_OFFSET;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RIP; break;
+ case 4: Operand->Register = X86_REG_EIP; break;
+ case 2: Operand->Register = X86_REG_IP; break;
+ default: assert(0); return NULL;
+ }
+ switch (Operand->Length)
+ {
+ case 8: X86Instruction->Displacement = *((S64 *)Address); break;
+ case 4: X86Instruction->Displacement = (S64)*((S32 *)Address); break;
+ case 2: X86Instruction->Displacement = (S64)*((S16 *)Address); break;
+ case 1: X86Instruction->Displacement = (S64)*((S8 *)Address); break;
+ default: assert(0); return NULL;
+ }
+
+ Operand->Value_S64 = X86Instruction->Displacement;
+ X86Instruction->Relative = TRUE;
+
+ if ((Operand->Flags & OP_COND) && !X86Instruction->Displacement)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: Both conditions of branch go to same address\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ }
+
+ INSTR_INC(Operand->Length); // increment Instruction->Length and address
+ if (!Decode) continue;
+
+ assert((Operand->Flags & OP_EXEC) && (Instruction->Groups & ITYPE_EXEC));
+ Operand->TargetAddress = ApplyDisplacement((U64)Address, Instruction);
+ X86Instruction->Relative = TRUE;
+ X86_SET_ADDR();
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ X86Instruction->Segment = SEG_CS;
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ assert(Instruction->OperandCount == 1);
+ //DISASM_OUTPUT(("[SetOperand] AMODE_J (branch with relative offset)\n"));
+ if (Disassemble)
+ {
+ X86_WRITE_IP_OFFSET(Operand);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case AMODE_O: // word/dword offset
+ Operand->Type = OPTYPE_OFFSET;
+ Operand->Flags |= OP_ADDRESS;
+ SANITY_CHECK_OPERAND_SIZE();
+ switch (X86Instruction->AddressSize)
+ {
+ case 8:
+ if (Operand->Flags & OP_SIGNED) X86Instruction->Displacement = *((S64 *)Address);
+ else X86Instruction->Displacement = (S64)*((U64 *)Address);
+ break;
+ case 4:
+ if (Operand->Flags & OP_SIGNED) X86Instruction->Displacement = (S64)*((S32 *)Address);
+ else X86Instruction->Displacement = (S64)*((U32 *)Address);
+ break;
+ case 2:
+ if (Operand->Flags & OP_SIGNED) X86Instruction->Displacement = (S64)*((S16 *)Address);
+ else X86Instruction->Displacement = (S64)*((U16 *)Address);
+ break;
+ default:
+ assert(0);
+ return FALSE;
+ }
+
+ INSTR_INC(X86Instruction->AddressSize); // increment Instruction->Length and address
+ if (!Decode) continue;
+
+ X86Instruction->HasFullDisplacement = TRUE;
+ X86_SET_ADDR();
+ X86_SET_TARGET();
+ assert(X86Instruction->Segment == SEG_DS || X86Instruction->HasSegmentOverridePrefix);
+ //DISASM_OUTPUT(("[SetOperand] AMODE_O (offset)\n"));
+ if (Disassemble)
+ {
+ X86_WRITE_OFFSET(Operand);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case AMODE_A: // absolute address
+ Operand->Flags |= OP_ADDRESS | OP_FAR;
+ SANITY_CHECK_ADDRESS_SIZE();
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ X86Instruction->HasSelector = TRUE;
+ X86Instruction->HasSegmentOverridePrefix = FALSE;
+ switch (Operand->Length)
+ {
+ case 6:
+ X86Instruction->Segment = *((U16 *)Address); INSTR_INC(2);
+ X86Instruction->Displacement = (S64)*((S32 *)Address); INSTR_INC(4);
+ break;
+ case 4:
+ X86Instruction->Segment = *((U16 *)Address); INSTR_INC(2);
+ X86Instruction->Displacement = (S64)*((S16 *)Address); INSTR_INC(2);
+ break;
+ default:
+ assert(0);
+ return FALSE;
+ }
+ if (!Decode) continue;
+ X86Instruction->HasFullDisplacement = TRUE;
+ X86_SET_ADDR();
+ X86_SET_TARGET();
+ //DISASM_OUTPUT(("[SetOperand] AMODE_A (absolute address)\n"));
+ if (Disassemble)
+ {
+ X86_WRITE_OFFSET(Operand);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case AMODE_X: // DS:[ESI]
+ if (!Decode) continue;
+ Operand->Flags |= OP_ADDRESS | OP_REG;
+ Operand->Type = OPTYPE_STRING;
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RSI; break;
+ case 4: Operand->Register = X86_REG_ESI; break;
+ case 2: Operand->Register = X86_REG_SI; break;
+ default: assert(0); return NULL;
+ }
+
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ X86_SET_ADDR();
+ if (!X86Instruction->HasSegmentOverridePrefix) X86Instruction->Segment = SEG_DS;
+
+ //DISASM_OUTPUT(("[SetOperand] AMODE_X (addressing via DS:[ESI])\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "%s:[%s]",
+ Segments[X86Instruction->Segment], X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ case AMODE_Y: // ES:[EDI]
+ if (!Decode) continue;
+ Operand->Flags |= OP_ADDRESS | OP_REG;
+ Operand->Type = OPTYPE_STRING;
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RDI; break;
+ case 4: Operand->Register = X86_REG_EDI; break;
+ case 2: Operand->Register = X86_REG_DI; break;
+ default: assert(0); return NULL;
+ }
+
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ X86_SET_ADDR();
+ if (X86Instruction->HasSegmentOverridePrefix)
+ {
+ if (!Instruction->AnomalyOccurred)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ANOMALY: segment override used with AMODE_Y\n", VIRTUAL_ADDRESS);
+ Instruction->AnomalyOccurred = TRUE;
+ }
+ Segment = X86Instruction->DstSegment = SEG_ES;
+ X86Instruction->HasDstSegment = TRUE;
+ }
+ else
+ {
+ Segment = X86Instruction->Segment = SEG_ES;
+ }
+
+ //DISASM_OUTPUT(("[SetOperand] AMODE_Y (addressing via ES:[EDI])\n"));
+ if (Disassemble)
+ {
+ APPEND(OPCSTR, SIZE_LEFT, "%s:[%s]",
+ Segments[Segment], X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ continue;
+
+ ////////////////////////////////////////////////////////////
+ // Mod R/M byte with only registers
+ // Handle that case here since it is straightforward
+ ////////////////////////////////////////////////////////////
+
+ case AMODE_PR: // modrm.rm = mmx register and modrm.mod = 11
+ assert(X86Instruction->HasModRM);
+ if (modrm.mod != 3)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: mod != 3 for AMODE_PR (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ else if (rex_modrm.rm > 7)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: invalid mmx register %d for AMODE_PR (\"%s\")\n", VIRTUAL_ADDRESS, rex_modrm.rm, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ else if (X86Instruction->OperandSize == 2)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: AMODE_PR illegal in 16-bit mode (\"%s\")\n", VIRTUAL_ADDRESS, rex_modrm.rm, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ if (!Decode) continue;
+
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_MMX_OFFSET + rex_modrm.rm;
+ X86_SET_REG(0);
+
+ if (Disassemble)
+ {
+ assert(X86_Registers[Operand->Register]);
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_PR (MMX register)\n"));
+ continue;
+
+ case AMODE_VR: // modrm.rm = xmm register and modrm.mod = 11
+ assert(X86Instruction->HasModRM);
+ if (modrm.mod != 3)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: mod != 3 for AMODE_VR (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ else if (X86Instruction->OperandSize == 2)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: AMODE_VR illegal in 16-bit mode (\"%s\")\n", VIRTUAL_ADDRESS, rex_modrm.rm, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ if (!Decode) continue;
+
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_XMM_OFFSET + rex_modrm.rm;
+ X86_SET_REG(0);
+
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_VR (XMM register)\n"));
+ continue;
+
+ case AMODE_P: // modrm.reg = mmx register
+ assert(X86Instruction->HasModRM);
+ if (rex_modrm.reg > 7)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: invalid mmx register %d for AMODE_P (\"%s\")\n", VIRTUAL_ADDRESS, rex_modrm.reg, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ else if (X86Instruction->OperandSize == 2)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: AMODE_P illegal in 16-bit mode (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ if (!Decode) continue;
+
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_MMX_OFFSET + rex_modrm.reg;
+ X86_SET_REG(0);
+
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_P (MMX register)\n"));
+ continue;
+
+ case AMODE_V: // modrm.reg = xmm register
+ assert(X86Instruction->HasModRM);
+ if (X86Instruction->OperandSize == 2)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: AMODE_P illegal in 16-bit mode (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ if (!Decode) continue;
+
+ Operand->Flags |= OP_REG;
+ Operand->Register = X86_XMM_OFFSET + rex_modrm.reg; break;
+ X86_SET_REG(0);
+
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_V (XMM register)\n"));
+ continue;
+
+ case AMODE_R: // modrm.rm is general register and modrm.mod = 11
+ assert(X86Instruction->HasModRM);
+ if (modrm.mod != 3)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: mod != 3 for AMODE_R (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ if (!Decode) continue;
+ Operand->Flags |= OP_REG;
+ switch (Operand->Length)
+ {
+ case 8: Operand->Register = AMD64_64BIT_OFFSET + rex_modrm.rm; break;
+ case 4: Operand->Register = X86_32BIT_OFFSET, rex_modrm.rm; CHECK_AMD64_REG(); break;
+ case 2: Operand->Register = X86_16BIT_OFFSET, rex_modrm.rm; CHECK_AMD64_REG(); break;
+ case 1: Operand->Register = X86_8BIT_OFFSET, rex_modrm.rm; if (X86Instruction->rex_b) CHECK_AMD64_REG(); break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_REG(rex_modrm.rm);
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_R (general register)\n"));
+ continue;
+
+ case AMODE_G: // modrm.reg = general register
+ assert(X86Instruction->HasModRM);
+ if (!Decode) continue;
+ Operand->Flags |= OP_REG;
+ switch (Operand->Length)
+ {
+ case 8: Operand->Register = AMD64_64BIT_OFFSET + rex_modrm.reg; break;
+ case 4: Operand->Register = X86_32BIT_OFFSET + rex_modrm.reg; CHECK_AMD64_REG(); break;
+ case 2: Operand->Register = X86_16BIT_OFFSET + rex_modrm.reg; CHECK_AMD64_REG(); break;
+ case 1: Operand->Register = X86_8BIT_OFFSET + rex_modrm.reg; if (X86Instruction->rex_b) CHECK_AMD64_REG(); break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_REG(rex_modrm.reg);
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_G (general register)\n"));
+ continue;
+
+ case AMODE_S: // modrm.reg = segment register
+ assert(X86Instruction->HasModRM);
+ if (!Decode) continue;
+ Operand->Flags |= OP_REG;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8:
+ case 4:
+ case 2:
+ if (rex_modrm.reg <= 5) Operand->Register = X86_SEGMENT_OFFSET + rex_modrm.reg;
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+
+ X86_SET_REG(0);
+ if (Disassemble)
+ {
+ if (rex_modrm.reg > 5) APPEND(OPCSTR, SIZE_LEFT, "seg_%02X", rex_modrm.reg);
+ else APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_S (segment register)\n"));
+ continue;
+
+ case AMODE_T: // modrm.reg = test register
+ assert(X86Instruction->HasModRM);
+ if (!Decode) continue;
+ Instruction->Groups |= ITYPE_SYSTEM;
+ Instruction->NeedsEmulation = TRUE;
+ Operand->Flags |= OP_REG;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8:
+ case 4:
+ case 2:
+ Operand->Register = X86_TEST_OFFSET + rex_modrm.reg;
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+
+ X86_SET_REG(0);
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_T (test register)\n"));
+ continue;
+
+ case AMODE_C: // modrm.reg = control register
+ assert(X86Instruction->HasModRM);
+ assert(Instruction->Type == ITYPE_MOV);
+ if (!Decode) continue;
+ Instruction->Groups |= ITYPE_SYSTEM;
+ Instruction->NeedsEmulation = TRUE;
+ Operand->Flags |= OP_REG;
+ if (IS_AMD64()) X86Instruction->OperandSize = 8;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8:
+ case 4:
+ case 2:
+ Operand->Register = X86_CONTROL_OFFSET + rex_modrm.reg;
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+
+ X86_SET_REG(0);
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_C (control register)\n"));
+ continue;
+
+ case AMODE_D: // modrm.reg = debug register
+ assert(X86Instruction->HasModRM);
+ assert(Instruction->Type == ITYPE_MOV);
+ if (!Decode) continue;
+ Instruction->NeedsEmulation = TRUE;
+ Operand->Flags |= OP_REG;
+ Instruction->Groups |= ITYPE_SYSTEM;
+ Instruction->NeedsEmulation = TRUE;
+ if (IS_AMD64()) X86Instruction->OperandSize = 8;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8:
+ case 4:
+ case 2:
+ Operand->Register = X86_DEBUG_OFFSET + rex_modrm.reg;
+ break;
+ default:
+ assert(0);
+ return NULL;
+ }
+
+ X86_SET_REG(0);
+ if (Disassemble)
+ {
+ APPENDS(X86_Registers[Operand->Register]);
+ X86_WRITE_OPFLAGS();
+ }
+ //DISASM_OUTPUT(("[SetOperand] AMODE_D (debug register)\n"));
+ continue;
+
+ ////////////////////////////////////////////////////////////
+ // Mod R/M byte with memory or register
+ ////////////////////////////////////////////////////////////
+
+ case AMODE_M: // memory only
+ assert(X86Instruction->HasModRM);
+ if (modrm.mod == 3)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: mod = 3 for AMODE_M (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ assert(X86Instruction->Segment == SEG_DS || X86Instruction->HasSegmentOverridePrefix);
+ //DISASM_OUTPUT(("[SetOperand] AMODE_M (memory only)\n"));
+ Address = SetModRM32(Instruction, Address, Operand, OperandIndex, SuppressErrors);
+ if (!Address) return NULL;
+ break;
+
+ case AMODE_E: // general register or memory
+ assert(X86Instruction->HasModRM);
+ if (OperandType == OPTYPE_p && modrm.mod == 3)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: mod = 3 for AMODE_E with OPTYPE_p (\"%s\")\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+
+ //DISASM_OUTPUT(("[SetOperand] AMODE_E (general register or memory)\n"));
+ Address = SetModRM32(Instruction, Address, Operand, OperandIndex, SuppressErrors);
+ if (!Address) return NULL;
+ if (Decode && (Instruction->Type == ITYPE_PUSH || Instruction->Type == ITYPE_POP))
+ {
+ assert(X86Instruction->OperandSize >= Operand->Length);
+ Operand->Length = X86Instruction->OperandSize;
+ }
+ break;
+
+ case AMODE_Q: // mmx register or memory address
+ assert(X86Instruction->HasModRM);
+ //DISASM_OUTPUT(("[SetOperand] AMODE_Q (MMX register or memory address)\n"));
+ if (modrm.mod == 3) // it is a register
+ {
+ if (rex_modrm.rm > 7)
+ {
+ if (!SuppressErrors) printf("[0x%08I64X] ERROR: invalid mmx register %d for AMODE_P (\"%s\")\n", VIRTUAL_ADDRESS, rex_modrm.rm, X86Instruction->Opcode.Mnemonic);
+ goto abort;
+ }
+ Operand->Register = X86_MMX_OFFSET + rex_modrm.rm;
+ Operand->Flags |= OP_REG;
+ X86_SET_REG(0);
+ }
+ else
+ {
+ Address = SetModRM32(Instruction, Address, Operand, OperandIndex, SuppressErrors);
+ if (!Address) return NULL;
+ }
+ break;
+
+ case AMODE_W: // xmm register or memory address
+ assert(X86Instruction->HasModRM);
+ //DISASM_OUTPUT(("[SetOperand] AMODE_W (XMM register or memory address)\n"));
+ if (modrm.mod == 3) // it is a register
+ {
+ Operand->Register = X86_XMM_OFFSET + rex_modrm.rm;
+ Operand->Flags |= OP_REG;
+ X86_SET_REG(0);
+ }
+ else
+ {
+ Address = SetModRM32(Instruction, Address, Operand, OperandIndex, SuppressErrors);
+ if (!Address) return NULL;
+ }
+ break;
+
+ default:
+ assert(0);
+ return NULL;
+ }
+
+ if (!Decode) continue;
+
+ // If this is reached then SetModRM32 was called
+ if ((Operand->Flags & OP_ADDRESS))
+ {
+ assert(Operand->Length);
+ switch (Operand->Register)
+ {
+ case X86_REG_BP:
+ case X86_REG_EBP:
+ case AMD64_REG_RBP:
+ if (X86Instruction->Displacement > 0) Operand->Flags |= OP_PARAM;
+ else Operand->Flags |= OP_LOCAL;
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (Disassemble)
+ {
+ Index = OperandType >> OPTYPE_SHIFT;
+ assert(Index > 0 && Index < MAX_OPTYPE_INDEX && OptypeHandlers[Index]);
+ OptypeHandlers[Index](Instruction, Operand, OperandIndex);
+ X86_WRITE_OPFLAGS();
+ }
+ }
+
+ return Address;
+
+abort:
+ if (!SuppressErrors)
+ {
+#ifdef TEST_DISASM
+ printf("Dump of 0x%04I64X:\n", VIRTUAL_ADDRESS);
+ __try { DumpAsBytes(stdout, Instruction->Address, (ULONG_PTR)VIRTUAL_ADDRESS, 16, TRUE); }
+ __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {}
+#endif
+ fflush(stdout);
+ }
+ return NULL;
+}
+
+// NOTE: Address points one byte after ModRM
+INTERNAL U8 *SetModRM16(INSTRUCTION *Instruction, U8 *Address, INSTRUCTION_OPERAND *Operand, U32 OperandIndex, BOOL SuppressErrors)
+{
+ MODRM modrm;
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+
+ DISASM_OUTPUT(("[SetModRM16] Current instruction length = %d\n", Instruction->Length));
+ modrm = X86Instruction->modrm;
+ assert(!X86Instruction->rex_b);
+
+ //
+ // Both operands are registers
+ // Condition: mod = 3
+ //
+ if (modrm.mod == 3)
+ {
+ //DISASM_OUTPUT(("[SetModRM16] Both regs (rm_reg %d)\n", modrm.rm));
+ switch (Operand->Length)
+ {
+ case 4: Operand->Register = X86_32BIT_OFFSET + modrm.rm; break;
+ case 2: Operand->Register = X86_16BIT_OFFSET + modrm.rm; break;
+ case 1: Operand->Register = X86_8BIT_OFFSET + modrm.rm; break;
+ default: assert(0); return NULL;
+ }
+ Operand->Flags |= OP_REG;
+ }
+
+ //
+ // Address is an absolute address (technically a 16-bit offset from DS:0)
+ // Condition: mod = 0 and rm = 6
+ //
+ else if (modrm.mod == 0 && modrm.rm == 6)
+ {
+ //DISASM_OUTPUT(("[SetModRM16] Absolute addressing (displacement 0x%04X)\n", *(S16 *)Address));
+ X86Instruction->Displacement = (S64)(*((S16 *)Address));
+ if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ X86Instruction->HasFullDisplacement = TRUE;
+ X86_SET_TARGET();
+ Operand->Flags |= OP_GLOBAL;
+ }
+ X86_SET_ADDR();
+ Operand->Flags |= OP_ADDRESS;
+ INSTR_INC(2);
+ }
+
+ // Conditions:
+ // (1) mod = 0 and rm != 6
+ // (2) mod = 1-2 and rm = 0-7
+ else
+ {
+ switch (modrm.mod)
+ {
+ case 0: // no displacement
+ //DISASM_OUTPUT(("[SetModRM16] Indirect addressing (no displacement)\n"));
+ break;
+ case 1: // 8-bit signed displacement
+ //DISASM_OUTPUT(("[SetModRM16] Indirect addressing (displacement = 0x%02X, reg_rm = %d)\n", *(S8 *)Address, modrm.rm));
+ X86Instruction->Displacement = (S64)(*((S8 *)Address));
+ INSTR_INC(1); // increment Instruction->Length and address
+ break;
+ case 2: // 16-bit displacement
+ //DISASM_OUTPUT(("[SetModRM16] Indirect addressing (displacement = 0x%04X, reg_rm = %d)\n", *(S16 *)Address, modrm.rm));
+ X86Instruction->Displacement = (S64)(*((S16 *)Address));
+ if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ Operand->Flags |= OP_GLOBAL;
+ X86Instruction->HasFullDisplacement = TRUE;
+ }
+ INSTR_INC(2);
+ break;
+ }
+
+ switch (modrm.rm)
+ {
+ case 0:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [BX+SI]\n"));
+ X86Instruction->BaseRegister = X86_REG_BX;
+ X86Instruction->IndexRegister = X86_REG_SI;
+ X86Instruction->HasIndexRegister = TRUE;
+ break;
+ case 1:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [BX+DI]\n"));
+ X86Instruction->BaseRegister = X86_REG_BX;
+ X86Instruction->IndexRegister = X86_REG_DI;
+ X86Instruction->HasIndexRegister = TRUE;
+ break;
+ case 2:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [BP+SI]\n"));
+ X86Instruction->BaseRegister = X86_REG_BP;
+ X86Instruction->IndexRegister = X86_REG_SI;
+ X86Instruction->HasIndexRegister = TRUE;
+ X86_SET_SEG(REG_BP);
+ break;
+ case 3:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [BP+DI]\n"));
+ X86Instruction->BaseRegister = X86_REG_BP;
+ X86Instruction->IndexRegister = X86_REG_DI;
+ X86Instruction->HasIndexRegister = TRUE;
+ X86_SET_SEG(REG_BP);
+ break;
+ case 4:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [SI]\n"));
+ X86Instruction->BaseRegister = X86_REG_SI;
+ break;
+ case 5:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [DI]\n"));
+ X86Instruction->BaseRegister = X86_REG_DI;
+ break;
+ case 6:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [BP]\n"));
+ X86Instruction->BaseRegister = X86_REG_BP;
+ break;
+ case 7:
+ //DISASM_OUTPUT(("[SetModRM16] Addressing mode [BX]\n"));
+ X86Instruction->BaseRegister = X86_REG_BX;
+ break;
+ }
+
+ X86Instruction->HasBaseRegister = TRUE;
+ Operand->Flags |= OP_ADDRESS | OP_REG;
+ X86_SET_ADDR();
+ }
+
+ return Address;
+}
+
+// NOTE: Address points one byte after ModRM
+INTERNAL U8 *SetModRM32(INSTRUCTION *Instruction, U8 *Address, INSTRUCTION_OPERAND *Operand, U32 OperandIndex, BOOL SuppressErrors)
+{
+ MODRM modrm;
+ REX_MODRM rex_modrm;
+ U32 i, ImmediateSize = 0;
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+
+ if (X86Instruction->AddressSize == 2)
+ {
+ return SetModRM16(Instruction, Address, Operand, OperandIndex, SuppressErrors);
+ }
+
+ //DISASM_OUTPUT(("[SetModRM32] Length %d, modrm = 0x%02X\n", Instruction->Length, X86Instruction->modrm_b));
+ modrm = X86Instruction->modrm;
+ rex_modrm = X86Instruction->rex_modrm;
+
+ //
+ // Both operands are registers
+ // Condition: mod = 3
+ //
+ if (modrm.mod == 3)
+ {
+ switch (Operand->Length)
+ {
+ case 8: Operand->Register = AMD64_64BIT_OFFSET + rex_modrm.rm; break;
+ case 4: Operand->Register = X86_32BIT_OFFSET + rex_modrm.rm; CHECK_AMD64_REG(); break;
+ case 2: Operand->Register = X86_16BIT_OFFSET + rex_modrm.rm; CHECK_AMD64_REG(); break;
+ case 1: Operand->Register = X86_8BIT_OFFSET + rex_modrm.rm; if (X86Instruction->rex_b) CHECK_AMD64_REG(); break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_REG(rex_modrm.rm);
+ Operand->Flags |= OP_REG;
+ }
+
+ //
+ // Address is an absolute address (technically a 32-bit offset from DS:0)
+ // mod = 0 and rm = 5
+ //
+ else if (modrm.mod == 0 && modrm.rm == 5)
+ {
+ //DISASM_OUTPUT(("[SetModRM32] Absolute addressing (displacement 0x%08lX)\n", *(S32 *)Address));
+ Operand->Flags |= OP_ADDRESS;
+ X86Instruction->Displacement = (S64)*((S32 *)Address);
+ INSTR_INC(4); // increment Instruction->Length and address
+
+ if (IS_AMD64())
+ {
+ // RIP-relative addressing always replaced Disp32, even when using a 32-bit address space
+ // (via address size override prefix)
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RIP; break;
+ case 4: Operand->Register = X86_REG_EIP; break;
+ case 2: Operand->Register = X86_REG_IP; break;
+ default: assert(0); return NULL;
+ }
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ X86Instruction->Relative = TRUE;
+ Operand->Flags |= OP_IPREL | OP_SIGNED | OP_REG;
+ SANITY_CHECK_SEGMENT_OVERRIDE();
+ if (!X86Instruction->HasSegmentOverridePrefix) X86Instruction->Segment = SEG_CS;
+ X86Instruction->HasFullDisplacement = TRUE;
+
+ // Since there may be an immediate value to follow, it is necessary
+ // to determine the length in order get the proper offset
+ //
+ // Maybe there is a better way to do this, since this is wasteful
+ // (the size of the immediate value will have to be decoded again later
+ // in SetOperands)
+
+ for (ImmediateSize = 0, i = OperandIndex+1; i < Instruction->OperandCount; i++)
+ {
+ if ((X86Instruction->Opcode.OperandFlags[i] & X86_AMODE_MASK) != AMODE_I) continue;
+ else assert(!ImmediateSize);
+ switch (X86Instruction->Opcode.OperandFlags[i] & X86_OPTYPE_MASK)
+ {
+ case OPTYPE_v:
+ ImmediateSize = X86Instruction->OperandSize;
+ break;
+ case OPTYPE_z:
+ switch (X86Instruction->OperandSize)
+ {
+ case 8: case 4: ImmediateSize = 4; break;
+ case 2: ImmediateSize = 2; break;
+ default: assert(0); return NULL;
+ }
+ break;
+ case OPTYPE_b:
+ ImmediateSize = 1;
+ break;
+ case OPTYPE_w:
+ ImmediateSize = 2;
+ break;
+ case OPTYPE_1:
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ }
+
+ Operand->TargetAddress = ApplyDisplacement((U64)Address + ImmediateSize, Instruction);
+ }
+ else if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ X86_SET_TARGET();
+ Operand->Flags |= OP_GLOBAL;
+ X86Instruction->HasFullDisplacement = TRUE;
+ }
+
+ X86_SET_ADDR();
+ }
+
+ //
+ // Addressing mode indicated by SIB byte
+ // Condition: mod = 0-2 and rm = 4
+ //
+ else if (modrm.rm == 4)
+ {
+ // The X86_SET_*() is called from within SetSIB()
+ Address = SetSIB(Instruction, Address, Operand, OperandIndex, SuppressErrors);
+ if (!Address)
+ {
+ assert(0);
+ return NULL;
+ }
+
+ if (X86Instruction->sib.base != 5) // if base == 5, the displacement is handled in SetSIB
+ {
+ switch (modrm.mod)
+ {
+ case 1: // 8-bit displacement
+ //DISASM_OUTPUT(("[SetModRM32] After SIB: displacement 0x%02X\n", *((S8 *)Address)));
+ X86Instruction->Displacement = (S64)(*((S8 *)Address));
+ INSTR_INC(1); // increment Instruction->Length and address
+ break;
+ case 2: // 32-bit displacement
+ //DISASM_OUTPUT(("[SetModRM32] After SIB: displacement 0x%08lX\n", *((S32 *)Address)));
+ X86Instruction->Displacement = (S64)*((S32 *)Address);
+ if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ Operand->Flags |= OP_GLOBAL;
+ X86Instruction->HasFullDisplacement = TRUE;
+ }
+ INSTR_INC(4); // increment Instruction->Length and address
+ break;
+ }
+ }
+ }
+
+ // Indirect addressing
+ // Conditions:
+ // (1) mod = 0 and (rm = 0-3 or 6-7)
+ // (2) mod = 1-2 and rm != 4
+ else
+ {
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_64BIT_OFFSET + rex_modrm.rm; break;
+ case 4: Operand->Register = X86_32BIT_OFFSET + rex_modrm.rm; CHECK_AMD64_REG(); break;
+ default: assert(0); return NULL;
+ }
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ Operand->Flags |= OP_ADDRESS | OP_REG;
+ X86_SET_SEG(rex_modrm.rm);
+ X86_SET_ADDR();
+
+ switch (modrm.mod)
+ {
+ case 0: // no displacement
+ //DISASM_OUTPUT(("[SetModRM32] Indirect addressing (no displacement, reg_rm = %d)\n", rex_modrm.rm));
+ break;
+ case 1: // 8-bit signed displacement
+ //DISASM_OUTPUT(("[SetModRM32] Indirect addressing (displacement = 0x%02X, reg_rm = %d)\n", *(S8 *)Address, rex_modrm.rm));
+ X86Instruction->Displacement = (S64)(*((S8 *)Address));
+ INSTR_INC(1); // increment Instruction->Length and address
+ break;
+ case 2: // 32-bit displacement
+ //DISASM_OUTPUT(("[SetModRM32] Indirect addressing (displacement = 0x%08lX, reg_rm = %d)\n", *(S32 *)Address, rex_modrm.rm));
+ X86Instruction->Displacement = (S64)*((S32 *)Address);
+ if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ Operand->Flags |= OP_GLOBAL;
+ X86Instruction->HasFullDisplacement = TRUE;
+ }
+ INSTR_INC(4); // increment Instruction->Length and address
+ break;
+ }
+ }
+
+ return Address;
+}
+
+// NOTE: Address points at SIB
+INTERNAL U8 *SetSIB(INSTRUCTION *Instruction, U8 *Address, INSTRUCTION_OPERAND *Operand, U32 OperandIndex, BOOL SuppressErrors)
+{
+ REX rex;
+ SIB sib;
+ REX_SIB rex_sib;
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+
+ X86Instruction->sib_b = *Address;
+ SET_SIB(X86Instruction->sib, *Address);
+ sib = X86Instruction->sib;
+ rex = X86Instruction->rex;
+ SET_REX_SIB(X86Instruction->rex_sib, rex, sib);
+ rex_sib = X86Instruction->rex_sib;
+
+ //if (!X86Instruction->rex_b) DISASM_OUTPUT(("[0x%08I64X] SIB = 0x%02X (scale=%d, index=%d, base=%d)\n", VIRTUAL_ADDRESS, *Address, sib.scale, sib.index, sib.base)); \
+ //else DISASM_OUTPUT(("[0x%08I64X] SIB = 0x%02X (scale=%d, index=%d, base=%d)\n", VIRTUAL_ADDRESS, *Address, sib.scale, rex_sib.index, rex_sib.base)); \
+ //DISASM_OUTPUT(("[SetSIB] Current instruction length = %d\n", Instruction->Length));
+
+ Operand->Flags |= OP_ADDRESS;
+ X86_SET_ADDR();
+ INSTR_INC(1); // increment Instruction->Length and address
+
+ if (sib.base == 5)
+ {
+ switch (X86Instruction->modrm.mod)
+ {
+ case 0:
+ X86Instruction->Displacement = (S64)*((S32 *)Address);
+ if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ X86Instruction->HasFullDisplacement = TRUE;
+ X86_SET_TARGET();
+ Operand->Flags |= OP_GLOBAL;
+ }
+ INSTR_INC(4);
+ break;
+ case 1:
+ X86Instruction->Displacement = (S64)(*((S8 *)Address));
+ if (rex_sib.base == 5)
+ {
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RBP; break;
+ case 4: Operand->Register = X86_REG_EBP; break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_SEG(REG_EBP);
+ }
+ else
+ {
+ Operand->Register = AMD64_REG_R13;
+ }
+
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ Operand->Flags |= OP_REG;
+ INSTR_INC(1);
+ break;
+ case 2:
+ X86Instruction->Displacement = (S64)*((S32 *)Address);
+ if (rex_sib.base == 5)
+ {
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_REG_RBP; break;
+ case 4: Operand->Register = X86_REG_EBP; break;
+ default: assert(0); return NULL;
+ }
+ X86_SET_SEG(REG_EBP);
+ }
+ else
+ {
+ Operand->Register = AMD64_REG_R13;
+ }
+
+ if (IS_VALID_ADDRESS(X86Instruction->Displacement))
+ {
+ Operand->Flags |= OP_GLOBAL;
+ X86Instruction->HasFullDisplacement = TRUE;
+ }
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ Operand->Flags |= OP_REG;
+ INSTR_INC(4);
+ break;
+ }
+ }
+ else
+ {
+ switch (X86Instruction->AddressSize)
+ {
+ case 8: Operand->Register = AMD64_64BIT_OFFSET + rex_sib.base; break;
+ case 4: Operand->Register = X86_32BIT_OFFSET + rex_sib.base; CHECK_AMD64_REG(); break;
+ default: assert(0); return NULL;
+ }
+ X86Instruction->BaseRegister = Operand->Register;
+ X86Instruction->HasBaseRegister = TRUE;
+ X86_SET_SEG(rex_sib.base);
+ Operand->Flags |= OP_REG;
+ }
+
+ if (rex_sib.index != 4)
+ {
+ switch (X86Instruction->AddressSize)
+ {
+ case 8:
+ X86Instruction->IndexRegister = AMD64_64BIT_OFFSET + rex_sib.index;
+ break;
+ case 4:
+ X86Instruction->IndexRegister = X86_32BIT_OFFSET + rex_sib.index;
+ break;
+ default:
+ fflush(stdout);
+ assert(0);
+ return NULL;
+ }
+
+ Operand->TargetAddress = 0;
+ X86Instruction->HasIndexRegister = TRUE;
+ //DISASM_OUTPUT(("[SetSIB] Index register = %s\n", X86_Registers[X86_32BIT_OFFSET + rex_sib.index]));
+
+ switch (sib.scale)
+ {
+ case 0: X86Instruction->Scale = 1; break;
+ case 1: X86Instruction->Scale = 2; break;
+ case 2: X86Instruction->Scale = 4; break;
+ case 3: X86Instruction->Scale = 8; break;
+ }
+ //DISASM_OUTPUT(("[SetSIB] Scale = %d\n", X86Instruction->Scale));
+ }
+
+ return Address;
+}
+
+INTERNAL U64 ApplyDisplacement(U64 Address, INSTRUCTION *Instruction)
+{
+ X86_INSTRUCTION *X86Instruction = &Instruction->X86;
+
+#ifdef SUPPORT_WRAPAROUND
+ U64 VirtualAddress = Address + Instruction->VirtualAddressDelta;
+ switch (X86Instruction->OperandSize)
+ {
+ case 8:
+ {
+ U64 PreAddr = VirtualAddress;
+ U64 PostAddr = PreAddr + X86Instruction->Displacement;
+ return Address + (PostAddr - PreAddr);
+ }
+ case 4:
+ {
+ // We have to do this carefully...
+ // If EIP = FFFFF000 and Displacement=2000 then the final IP should be 1000
+ // due to wraparound
+ U32 PreAddr = (U32)VirtualAddress;
+ U32 PostAddr = PreAddr + (S32)X86Instruction->Displacement;
+ return Address + (PostAddr - PreAddr);
+ }
+ case 2:
+ {
+ // We have to do this carefully...
+ // If IP = F000 and Displacement=2000 then the final IP should be 1000
+ // due to wraparound
+ U16 PreAddr = (U16)VirtualAddress;
+ U16 PostAddr = PreAddr + (S16)X86Instruction->Displacement;
+ return Address + (PostAddr - PreAddr);
+ }
+ default:
+ assert(0);
+ return 0;
+ }
+#else
+ return (Address + X86Instruction->Displacement);
+#endif
+}
+
+
+
+INTERNAL BOOL IsValidLockPrefix(X86_INSTRUCTION *X86Instruction, U8 Opcode, U32 OpcodeLength, U8 Group, U8 OpcodeExtension)
+{
+ switch (OpcodeLength)
+ {
+ case 1:
+ switch (X86_LockPrefix_1[Opcode])
+ {
+ case 0: // instruction can't be locked
+ return FALSE;
+ case 1: // instruction can be locked
+ break;
+ case GR:
+ assert(Group);
+ if (!X86_LockPrefix_Groups[Group-1][OpcodeExtension]) return FALSE;
+ break;
+ default:
+ assert(0);
+ return FALSE;
+ }
+ break;
+
+ case 2:
+ case 3:
+ switch (X86_LockPrefix_2[Opcode])
+ {
+ case 0: // lock prefix is not acceptable
+ return FALSE;
+ case 1: // lock prefix allowed
+ break;
+ case GR:
+ assert(Group);
+ if (!X86_LockPrefix_Groups[Group-1][OpcodeExtension]) return FALSE;
+ break;
+ default:
+ assert(0);
+ return FALSE;
+ }
+ break;
+
+ default:
+ assert(0);
+ return FALSE;
+ }
+
+ if (!X86Instruction->HasModRM || X86Instruction->modrm.mod == 3 || !X86Instruction->HasDstAddressing)
+ {
+ DISASM_OUTPUT(("[0x%08I64X] ERROR: Instruction \"%s\" with LOCK prefix has invalid ModRM addressing\n", VIRTUAL_ADDRESS, X86Instruction->Opcode.Mnemonic, X86Instruction->Instruction->Address));
+ return FALSE;
+ }
+
+ return TRUE;
+}
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86.h b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86.h
new file mode 100644
index 0000000..aa9a90e
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86.h
@@ -0,0 +1,836 @@
+// Copyright (C) 2004, Matt Conover (mconover@gmail.com)
+#ifndef X86_DISASM_H
+#define X86_DISASM_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// NOTE: the processor may actually accept less than this amount (officially 15)
+// #define AMD64_MAX_INSTRUCTION_LEN 15 // theoretical max 25=5+2+1+1+8+8
+#define AMD64_MAX_PREFIX_LENGTH 5 // 4 legacy + 1 rex
+#define AMD64_MAX_ADDRESS_LENGTH 18 // modrm + sib + 8 byte displacement + 8 byte immediate value
+
+// NOTE: the processor may actually accept less than this amount (officially 15)
+#define X86_MAX_INSTRUCTION_LEN 15 // theoretical 16=4+2+1+1+4+4
+#define X86_MAX_PREFIX_LENGTH 4
+#define X86_MAX_OPCODE_LENGTH 3 // third byte is either a suffix or prefix
+#define X86_MAX_ADDRESS_LENGTH 10 // modrm + sib + 4 byte displacement + 4 byte immediate value
+#define X86_MAX_OPERANDS 3
+
+#define X86_PREFIX(a) ((a)->MnemonicFlags == ITYPE_EXT_PREFIX)
+#define X86_SPECIAL_EXTENSION(a) ((a)->MnemonicFlags & (ITYPE_EXT_MODRM|ITYPE_EXT_FPU|ITYPE_EXT_SUFFIX|ITYPE_EXT_64))
+#define X86_EXTENDED_OPCODE(a) ((a)->Table)
+#define X86_INVALID(a) (!(a)->MnemonicFlags && !(a)->Table)
+#define X86_OPERAND_COUNT(a) ((a)->OperandFlags[0] ? ((a)->OperandFlags[1] ? ((a)->OperandFlags[2] ? 3 : 2) : 1) : 0)
+#define X86_GET_CATEGORY(p) ((p)->MnemonicFlags & ITYPE_GROUP_MASK)
+#define X86_GET_TYPE(p) ((p)->MnemonicFlags & ITYPE_TYPE_MASK)
+
+// Various instructions being specially decoded
+#define X86_TWO_BYTE_OPCODE 0x0f
+#define PREFIX_SEGMENT_OVERRIDE_ES 0x26
+#define PREFIX_SEGMENT_OVERRIDE_CS 0x2e
+#define PREFIX_BRANCH_NOT_TAKEN 0x2e // used only with conditional jumps
+#define PREFIX_SEGMENT_OVERRIDE_SS 0x36
+#define PREFIX_SEGMENT_OVERRIDE_DS 0x3e
+#define PREFIX_BRANCH_TAKEN 0x3e // used only with conditional jumps
+#define PREFIX_SEGMENT_OVERRIDE_FS 0x64
+#define PREFIX_SEGMENT_OVERRIDE_GS 0x65
+#define PREFIX_OPERAND_SIZE 0x66
+#define PREFIX_ADDRESS_SIZE 0x67
+#define PREFIX_LOCK 0xf0
+#define PREFIX_REPNE 0xf2
+#define PREFIX_REP 0xf3
+
+//////////////////////////////////////////////////////////////////
+// Implicit operand handling
+//////////////////////////////////////////////////////////////////
+
+#define X86_AMODE_MASK 0x00FF0000 // bits 16-23 (AMODE_*)
+#define X86_OPFLAGS_MASK 0x0000FF80 // bits 7-15 (OPTYPE_*)
+#define X86_OPTYPE_MASK 0xFF0000FF // bits 0-7 (OPTYPE_* below + OP_REG) and 24-31 (OPTYPE_* above)
+
+#define OPTYPE_0 0x01
+#define OPTYPE_1 0x02
+#define OPTYPE_FF 0x03
+//...
+#define OPTYPE_CS 0x10
+#define OPTYPE_DS 0x11
+#define OPTYPE_ES 0x12
+#define OPTYPE_FS 0x13
+#define OPTYPE_GS 0x14
+#define OPTYPE_SS 0x15
+#define OPTYPE_CR0 0x16
+#define OPTYPE_TSC 0x17 // time stamp counter
+//...
+#define OPTYPE_FLAGS 0x20
+#define OPTYPE_xFLAGS 0x21 // RFLAGS/EFLAGS (depending on operand size)
+#define OPTYPE_xCX_HI_xBX_LO 0x22 // represented by 2 registers CX:BX or ECX:EBX (depending on operand size)
+#define OPTYPE_xDX_HI_xAX_LO 0x23 // DX:AX or EDX:EAX (depending on operand size)
+#define OPTYPE_EDX_HI_EAX_LO 0x24 // DX:AX or EDX:EAX (depending on operand size)
+#define OPTYPE_EDX_ECX_EBX_EAX 0x25 // all registers are set
+//...
+#define OPTYPE_STx 0x30
+#define OPTYPE_ST0 0x31
+#define OPTYPE_ST1 0x32
+#define OPTYPE_FPU_STATUS 0x33
+#define OPTYPE_FPU_CONTROL 0x34
+#define OPTYPE_FPU_TAG 0x35
+#define OPTYPE_FLDZ 0x36 // 0
+#define OPTYPE_FLD1 0x37 // 1
+#define OPTYPE_FLDPI 0x38 // pi
+#define OPTYPE_FLDL2T 0x39 // lg 10
+#define OPTYPE_FLDL2E 0x3A // lg e
+#define OPTYPE_FLDLG2 0x3B // log_10 2
+#define OPTYPE_FLDLN2 0x3C // log_e 2
+//...
+#define OPTYPE_CS_MSR 0x40
+#define OPTYPE_EIP_MSR 0x41
+#define OPTYPE_ESP_MSR 0x42
+#define OPTYPE_KERNELBASE_MSR 0x43
+#define OPTYPE_FMASK_MSR 0x44
+#define OPTYPE_STAR_MSR 0x45
+#define OPTYPE_CSTAR_MSR 0x46 // 32-bit mode
+#define OPTYPE_LSTAR_MSR 0x47 // 64-bit mode
+
+
+// NOTE: OPTYPES >= 0x80 reserved for registers (OP_REG+XX)
+#define OPTYPE_REG_AL (OP_REG+0x01)
+#define OPTYPE_REG_CL (OP_REG+0x02)
+#define OPTYPE_REG_AH (OP_REG+0x03)
+#define OPTYPE_REG_AX (OP_REG+0x04)
+#define OPTYPE_REG_DX (OP_REG+0x05)
+#define OPTYPE_REG_ECX (OP_REG+0x06)
+#define OPTYPE_REG8 (OP_REG+0x07)
+
+// If address size is 2, use BP
+// If address size is 4, use EBP
+// If address size is 8, use RBP
+#define OPTYPE_REG_xBP (OP_REG+0x08)
+
+// If address size is 2, use BP
+// If address size is 4, use EBP
+// If address size is 8, use RBP
+#define OPTYPE_REG_xSP (OP_REG+0x09)
+
+// If operand size is 2, take 8-bit register
+// If operand size is 4, take 16-bit register
+// If operand size is 8, take 32-bit register
+#define OPTYPE_REG_xAX_SMALL (OP_REG+0x0a)
+// If operand size is 2, take 16-bit register
+// If operand size is 4, take 32-bit register
+// If operand size is 8, take 64-bit register
+#define OPTYPE_REG_xAX_BIG (OP_REG+0x0b)
+
+typedef enum _CPU_TYPE
+{
+ CPU_UNKNOWN=0,
+
+ ///////////////////////////////////////
+ // 1st generation
+ ///////////////////////////////////////
+ // 1978
+ //CPU_8086 = 1MB address limit, 16-bit registers
+ // 1982
+ //CPU_i186
+
+ ///////////////////////////////////////
+ // 2nd generation
+ ///////////////////////////////////////
+ // 1982
+ //CPU_I286 // 16MB limit, 16-bit registers, added protected mode
+ CPU_I287, // CPU_I286 + math coprocessor
+
+ ///////////////////////////////////////
+ // 3rd generation
+ ///////////////////////////////////////
+ // 1985
+ CPU_I386, // 32-bit registers, 4GB memory limit
+ // 1988
+ CPU_I387, // CPU_I386 + math coprocessor
+
+ ///////////////////////////////////////
+ // 4th generation (1989)
+ ///////////////////////////////////////
+ CPU_I486,
+
+ ///////////////////////////////////////
+ // 5th generation
+ ///////////////////////////////////////
+ // 1993
+ CPU_PENTIUM, // superscalar architecture
+ // 1997
+ //CPU_PENTIUM_MMX
+
+ ///////////////////////////////////////
+ // 6th generation (1995)
+ ///////////////////////////////////////
+ CPU_PENTIUM_PRO, // P6 architecture, no MMX, out-of-order execution, speculative execution
+ //CPU_CYRIX_6X86,
+ //CPU_AMD_K5 // RISC processor
+ // 1997
+ CPU_PENTIUM2, // Pentium Pro architecture + MMX
+ //CPU_AMD_K6,
+ //CPU_CYRIX_6X86MX, // Cyrix 6x86 + MMX
+ // 1998
+ CPU_AMD_K6_2, // added 3DNow! (MMX)
+ // 1999
+ // CPU_AMD_K6_3 // added SSE
+
+ ///////////////////////////////////////
+ // 7th generation
+ ///////////////////////////////////////
+ // 1999
+ CPU_PENTIUM3, // introduced SSE
+ // CPU_AMD_K7 // aka Athlon
+ // 2000
+ CPU_PENTIUM4, // introduced SSE2 and hyperthreading
+
+ // 2004? 2005?
+ CPU_PRESCOTT, // introduced SSE3
+
+ ///////////////////////////////////////
+ // 8th generation (X86-64)
+ // IA32 instruction set with 64-bit extensions, >4GB RAM
+ ///////////////////////////////////////
+
+ // 2003
+ CPU_AMD64, // includes Athlon 64 and Opteron aka X86-64
+
+ // 2004?
+ //CPU_EMD64 // Intel's version of AMD64
+ CPU_IA64 // aka Itanium: new instruction set -- adds JMPE to IA32 mode to return to IA64 native code
+
+} CPU_TYPE;
+
+//////////////////////////////////////////////////////////////////
+// Conditions (these can be OR'd)
+//////////////////////////////////////////////////////////////////
+
+// Used for Flags.Preconditions
+#define COND_O (1<<0) // overflow (signed)
+#define COND_C (1<<1) // below (unsigned)
+#define COND_Z (1<<2) // equal (unsigned)
+#define COND_S (1<<3) // sign set (signed)
+#define COND_P (1<<4) // parity even
+#define COND_BE (1<<5) // CF or ZF is set (unsigned)
+#define COND_L (1<<6) // (SF && !OF) || (OF && !SF)
+#define COND_LE (1<<7) // ZF || (SF && !OF) || (OF && !SF) (signed)
+#define COND_NO (1<<8) // !O
+#define COND_NC (1<<9) // !C (not below, above or equal to)
+#define COND_NZ (1<<10) // !Z (not equal)
+#define COND_NS (1<<11) // !S
+#define COND_NP (1<<12) // !P (parity odd)
+#define COND_NL (1<<13) // (!SF && !OF) || (SF && OF)
+#define COND_G (1<<14) // !ZF && ((!SF && !OF) || (SF && OF))
+#define COND_D (1<<15) // DF
+#define COND_REG_xCX_BIG_Z (1<<16) // CX/ECX/RCX (depending on address size) == 0
+#define COND_REG_xCX_BIG_NZ (1<<17) // CX/ECX/RCX (depending on address size) != 0
+#define COND_OP1_EQ_OP2 (1<<18)
+#define COND_OP1_EQ_OP3 (1<<19)
+#define COND_B COND_C
+#define COND_NAE COND_C
+#define COND_E COND_Z
+#define COND_NA COND_BE
+#define COND_PE COND_P
+#define COND_U COND_P
+#define COND_NGE COND_L
+#define COND_NG COND_LE
+#define COND_PO COND_NP
+#define COND_NU COND_NP
+#define COND_NE COND_NZ
+#define COND_NB COND_NC
+#define COND_AE COND_NC
+#define COND_NE COND_NZ
+#define COND_A (COND_NC|COND_NZ)
+#define COND_NBE COND_A
+#define COND_GE COND_NL
+#define COND_NLE COND_G
+
+// Used for Opcode.FlagsChanged
+#define FLAG_CF_SET (1<<0)
+#define FLAG_DF_SET (1<<1)
+#define FLAG_IF_SET (1<<2)
+#define FLAG_SET_MASK (FLAG_CF_SET|FLAG_DF_SET|FLAG_IF_SET)
+
+#define FLAG_SF_CLR (1<<3)
+#define FLAG_ZF_CLR (1<<4)
+#define FLAG_AF_CLR (1<<5)
+#define FLAG_CF_CLR (1<<6)
+#define FLAG_DF_CLR (1<<7)
+#define FLAG_IF_CLR (1<<8)
+#define FLAG_OF_CLR (1<<9)
+#define FPU_C0_CLR (1<<19)
+#define FPU_C1_CLR (1<<20)
+#define FPU_C2_CLR (1<<21)
+#define FPU_C3_CLR (1<<22)
+#define FPU_ALL_CLR (FPU_C0_CLR|FPU_C1_CLR|FPU_C2_CLR|FPU_C3_CLR)
+#define FLAG_CLR_MASK (FLAG_SF_CLR|FLAG_ZF_CLR|FLAG_AF_CLR|FLAG_CF_CLR|FLAG_DF_CLR|FLAG_IF_CLR|FLAG_OF_CLR|FPU_ALL_CLR)
+
+#define FLAG_OF_MOD (1<<10)
+#define FLAG_SF_MOD (1<<11)
+#define FLAG_ZF_MOD (1<<12)
+#define FLAG_AF_MOD (1<<13)
+#define FLAG_PF_MOD (1<<14)
+#define FLAG_CF_MOD (1<<15)
+#define FLAG_DF_MOD (1<<16)
+#define FLAG_IF_MOD (1<<17)
+#define FLAG_ALL_MOD (FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD|FLAG_CF_MOD|FLAG_DF_MOD|FLAG_IF_MOD)
+#define FLAG_COMMON_MOD (FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD|FLAG_CF_MOD)
+#define FPU_C0_MOD (1<<23)
+#define FPU_C1_MOD (1<<24)
+#define FPU_C2_MOD (1<<25)
+#define FPU_C3_MOD (1<<26)
+#define FPU_ALL_MOD (FPU_C0_MOD|FPU_C1_MOD|FPU_C2_MOD|FPU_C3_MOD)
+#define FLAG_MOD_MASK (FLAG_ALL_MOD|FPU_ALL_MOD)
+
+#define FLAG_CF_TOG (1<<18)
+#define FLAG_TOG_MASK FLAG_CF_TOG
+
+// Used for Opcode.ResultsIfTrue and Opcode.ResultsIfFalse
+#define OP1_DST (1<<0)
+#define OP2_DST (1<<1)
+#define OP3_DST (1<<2)
+#define OP1_SRC (1<<3)
+#define OP2_SRC (1<<4)
+#define OP3_SRC (1<<5)
+#define FPU_STACK_INC (1<<6)
+#define FPU_STACK_INC2 (1<<7)
+#define FPU_STACK_DEC (1<<8)
+#define SERIALIZE_WRITE (1<<9)
+#define SERIALIZE_READ (1<<10)
+#define xCX_DEC (1<<11)
+#define xCX_REP_DEC (1<<12)
+#define xDI_DEC (1<<13)
+#define xDI_INC (1<<14)
+#define xSI_DEC (1<<15)
+#define xSI_INC (1<<16)
+#define xDI_DECx (1<<17)
+#define xDI_INCx (1<<18)
+#define xSI_DECx (1<<19)
+#define xSI_INCx (1<<20)
+#define FPU_STACK_PUSH FPU_STACK_DEC
+#define FPU_STACK_POP FPU_STACK_INC
+#define FPU_STACK_POP2 FPU_STACK_INC2
+#define SERIALIZE_ALL (SERIALIZE_WRITE|SERIALIZE_READ)
+
+#define X86_SEGMENT_OFFSET 0x00
+#define X86_TEST_OFFSET 0x10
+#define X86_CONTROL_OFFSET 0x20
+#define X86_DEBUG_OFFSET 0x30
+#define X86_FPU_OFFSET 0x40
+#define X86_MMX_OFFSET 0x50
+#define X86_XMM_OFFSET 0x60
+#define X86_8BIT_OFFSET 0x70
+#define X86_16BIT_OFFSET 0x80
+#define X86_32BIT_OFFSET 0x90
+#define AMD64_8BIT_OFFSET 0xA0
+#define AMD64_16BIT_OFFSET 0xB0
+#define AMD64_32BIT_OFFSET 0xC0
+#define AMD64_64BIT_OFFSET 0xD0
+
+typedef enum _X86_REGISTER
+{
+ // Segments
+ X86_SEG_ES = X86_SEGMENT_OFFSET,
+ X86_SEG_CS,
+ X86_SEG_SS,
+ X86_SEG_DS,
+ X86_SEG_FS,
+ X86_SEG_GS,
+
+ // Miscellaneous
+ X86_REG_FLAGS,
+ X86_REG_EFLAGS,
+ AMD64_REG_RFLAGS,
+ X86_REG_IP,
+ X86_REG_EIP,
+ AMD64_REG_RIP,
+
+ // Test registers
+ X86_REG_TR0 = X86_TEST_OFFSET,
+ X86_REG_TR1,
+ X86_REG_TR2,
+ X86_REG_TR3,
+ X86_REG_TR4,
+ X86_REG_TR5,
+ X86_REG_TR6,
+ X86_REG_TR7,
+ X86_REG_TR8,
+ X86_REG_TR9,
+ X86_REG_TR10,
+ X86_REG_TR11,
+ X86_REG_TR12,
+ X86_REG_TR13,
+ X86_REG_TR14,
+ X86_REG_TR15,
+
+ // Control registers
+ X86_REG_CR0=X86_CONTROL_OFFSET,
+ X86_REG_CR1,
+ X86_REG_CR2,
+ X86_REG_CR3,
+ X86_REG_CR4,
+ X86_REG_CR5,
+ X86_REG_CR6,
+ X86_REG_CR7,
+ X86_REG_CR8,
+ X86_REG_CR9,
+ X86_REG_CR10,
+ X86_REG_CR11,
+ X86_REG_CR12,
+ X86_REG_CR13,
+ X86_REG_CR14,
+ X86_REG_CR15,
+
+ // Debug registers
+ X86_REG_DR0=X86_DEBUG_OFFSET,
+ X86_REG_DR1,
+ X86_REG_DR2,
+ X86_REG_DR3,
+ X86_REG_DR4,
+ X86_REG_DR5,
+ X86_REG_DR6,
+ X86_REG_DR7,
+ X86_REG_DR8,
+ X86_REG_DR9,
+ X86_REG_DR10,
+ X86_REG_DR11,
+ X86_REG_DR12,
+ X86_REG_DR13,
+ X86_REG_DR14,
+ X86_REG_DR15,
+
+ // FPU registers
+ X86_REG_ST0=X86_FPU_OFFSET,
+ X86_REG_ST1,
+ X86_REG_ST2,
+ X86_REG_ST3,
+ X86_REG_ST4,
+ X86_REG_ST5,
+ X86_REG_ST6,
+ X86_REG_ST7,
+
+ // MMX registers
+ X86_REG_MM0=X86_MMX_OFFSET,
+ X86_REG_MM1,
+ X86_REG_MM2,
+ X86_REG_MM3,
+ X86_REG_MM4,
+ X86_REG_MM5,
+ X86_REG_MM6,
+ X86_REG_MM7,
+
+ // XMM registers
+ X86_REG_XMM0=X86_XMM_OFFSET,
+ X86_REG_XMM1,
+ X86_REG_XMM2,
+ X86_REG_XMM3,
+ X86_REG_XMM4,
+ X86_REG_XMM5,
+ X86_REG_XMM6,
+ X86_REG_XMM7,
+
+ // 8-bit registers
+ X86_REG_AL=X86_8BIT_OFFSET,
+ X86_REG_CL,
+ X86_REG_DL,
+ X86_REG_BL,
+ X86_REG_AH,
+ X86_REG_CH,
+ X86_REG_DH,
+ X86_REG_BH,
+
+ // 16-bit registers
+ X86_REG_AX=X86_16BIT_OFFSET,
+ X86_REG_CX,
+ X86_REG_DX,
+ X86_REG_BX,
+ X86_REG_SP,
+ X86_REG_BP,
+ X86_REG_SI,
+ X86_REG_DI,
+
+ // 32-bit registers
+ X86_REG_EAX=X86_32BIT_OFFSET,
+ X86_REG_ECX,
+ X86_REG_EDX,
+ X86_REG_EBX,
+ X86_REG_ESP,
+ X86_REG_EBP,
+ X86_REG_ESI,
+ X86_REG_EDI,
+
+ // AMD64 8-bit registers
+ AMD64_REG_AL=AMD64_8BIT_OFFSET,
+ AMD64_REG_CL,
+ AMD64_REG_DL,
+ AMD64_REG_BL,
+ AMD64_REG_SPL,
+ AMD64_REG_BPL,
+ AMD64_REG_SIL,
+ AMD64_REG_DIL,
+ AMD64_REG_R8B,
+ AMD64_REG_R9B,
+ AMD64_REG_R10B,
+ AMD64_REG_R11B,
+ AMD64_REG_R12B,
+ AMD64_REG_R13B,
+ AMD64_REG_R14B,
+ AMD64_REG_R15B,
+
+ // AMD64 16-bit registers
+ AMD64_REG_AX=AMD64_16BIT_OFFSET,
+ AMD64_REG_CX,
+ AMD64_REG_DX,
+ AMD64_REG_BX,
+ AMD64_REG_SP,
+ AMD64_REG_BP,
+ AMD64_REG_SI,
+ AMD64_REG_DI,
+ AMD64_REG_R8W,
+ AMD64_REG_R9W,
+ AMD64_REG_R10W,
+ AMD64_REG_R11W,
+ AMD64_REG_R12W,
+ AMD64_REG_R13W,
+ AMD64_REG_R14W,
+ AMD64_REG_R15W,
+
+ // AMD64 32-bit registers
+ AMD64_REG_EAX=AMD64_32BIT_OFFSET,
+ AMD64_REG_ECX,
+ AMD64_REG_EDX,
+ AMD64_REG_EBX,
+ AMD64_REG_ESP,
+ AMD64_REG_EBP,
+ AMD64_REG_ESI,
+ AMD64_REG_EDI,
+ AMD64_REG_R8D,
+ AMD64_REG_R9D,
+ AMD64_REG_R10D,
+ AMD64_REG_R11D,
+ AMD64_REG_R12D,
+ AMD64_REG_R13D,
+ AMD64_REG_R14D,
+ AMD64_REG_R15D,
+
+ // AMD64 64-bit registers
+ AMD64_REG_RAX=AMD64_64BIT_OFFSET,
+ AMD64_REG_RCX,
+ AMD64_REG_RDX,
+ AMD64_REG_RBX,
+ AMD64_REG_RSP,
+ AMD64_REG_RBP,
+ AMD64_REG_RSI,
+ AMD64_REG_RDI,
+ AMD64_REG_R8,
+ AMD64_REG_R9,
+ AMD64_REG_R10,
+ AMD64_REG_R11,
+ AMD64_REG_R12,
+ AMD64_REG_R13,
+ AMD64_REG_R14,
+ AMD64_REG_R15
+} X86_REGISTER;
+
+typedef enum _X86_TEST_REGISTER
+{
+ REG_TR0=0,
+ REG_TR1,
+ REG_TR2,
+ REG_TR3,
+ REG_TR4,
+ REG_TR5,
+ REG_TR6,
+ REG_TR7,
+ REG_TR8,
+ REG_TR9,
+ REG_TR10,
+ REG_TR11,
+ REG_TR12,
+ REG_TR13,
+ REG_TR14,
+ REG_TR15
+} X86_TEST_REGISTER;
+
+typedef enum _X86_CONTROL_REGISTER
+{
+ REG_CR0,
+ REG_CR1,
+ REG_CR2,
+ REG_CR3,
+ REG_CR4,
+ REG_CR5,
+ REG_CR6,
+ REG_CR7,
+ REG_CR8,
+ REG_CR9,
+ REG_CR10,
+ REG_CR11,
+ REG_CR12,
+ REG_CR13,
+ REG_CR14,
+ REG_CR15
+} X86_CONTROL_REGISTER;
+
+typedef enum _X86_DEBUG_REGISTER
+{
+ REG_DR0,
+ REG_DR1,
+ REG_DR2,
+ REG_DR3,
+ REG_DR4,
+ REG_DR5,
+ REG_DR6,
+ REG_DR7,
+ REG_DR8,
+ REG_DR9,
+ REG_DR10,
+ REG_DR11,
+ REG_DR12,
+ REG_DR13,
+ REG_DR14,
+ REG_DR15
+} X86_DEBUG_REGISTER;
+
+typedef enum _X86_MMX_REGISTER
+{
+ REG_MM0=0,
+ REG_MM1=1,
+ REG_MM2=2,
+ REG_MM3=3,
+ REG_MM4=4,
+ REG_MM5=5,
+ REG_MM6=6,
+ REG_MM7=7
+} X86_MMX_REGISTER;
+
+typedef enum _X86_SSE_REGISTER
+{
+ REG_XMM0=0,
+ REG_XMM1=1,
+ REG_XMM2=2,
+ REG_XMM3=3,
+ REG_XMM4=4,
+ REG_XMM5=5,
+ REG_XMM6=6,
+ REG_XMM7=7
+} X86_SSE_REGISTER;
+
+typedef enum _X86_FPU_REGISTER
+{
+ REG_ST0=0,
+ REG_ST1=1,
+ REG_ST2=2,
+ REG_ST3=3,
+ REG_ST4=4,
+ REG_ST5=5,
+ REG_ST6=6,
+ REG_ST7=7
+} X86_FPU_REGISTER;
+
+typedef enum _X86_8BIT_REGISTER
+{
+ REG_AL = 0,
+ REG_CL = 1,
+ REG_DL = 2,
+ REG_BL = 3,
+ REG_AH = 4,
+ REG_CH = 5,
+ REG_DH = 6,
+ REG_BH = 7
+} X86_8BIT_REGISTER;
+
+typedef enum _X86_16BIT_REGISTER
+{
+ REG_AX = 0,
+ REG_CX = 1,
+ REG_DX = 2,
+ REG_BX = 3,
+ REG_SP = 4,
+ REG_BP = 5,
+ REG_SI = 6,
+ REG_DI = 7
+} X86_16BIT_REGISTER;
+
+typedef enum _X86_32BIT_REGISTER
+{
+ REG_EAX = 0,
+ REG_ECX = 1,
+ REG_EDX = 2,
+ REG_EBX = 3,
+ REG_ESP = 4,
+ REG_EBP = 5,
+ REG_ESI = 6,
+ REG_EDI = 7
+} X86_32BIT_REGISTER;
+
+typedef enum _X86_SEGMENT
+{
+ SEG_ES = 0,
+ SEG_CS = 1,
+ SEG_SS = 2,
+ SEG_DS = 3,
+ SEG_FS = 4,
+ SEG_GS = 5,
+ SEG_MAX = 6
+} X86_SEGMENT;
+
+extern char *X86_Registers[];
+
+#pragma pack(push,1)
+typedef struct _MODRM
+{
+ U8 mod : 2;
+ U8 reg : 3;
+ U8 rm : 3;
+} MODRM;
+typedef struct _SIB
+{
+ U8 scale : 2;
+ U8 index : 3;
+ U8 base : 3;
+} SIB;
+typedef struct _REX
+{
+ U8 unused : 4; // bits 4,5,6,7
+ U8 w : 1; // bit 3
+ U8 r : 1; // bit 2
+ U8 x : 1; // bit 1
+ U8 b : 1; // bit 0
+} REX;
+typedef struct _REX_MODRM
+{
+ U8 reg : 4;
+ U8 rm : 4;
+} REX_MODRM;
+typedef struct _REX_SIB
+{
+ U8 index : 4;
+ U8 base : 4;
+} REX_SIB;
+#pragma pack(pop)
+
+//
+// Properties:
+// If an operand is OP_COND_EXEC, it means that it is executed only if the pre-conditions are met.
+//
+// If if an instruction has one or more OP_COND_DST operands, then the actions are determined by
+// whether the Opcode.Preconditions are met or not. If all the COND_* flags in Opcode.Preconditions
+// are true, then the results are determined by ResultsIfTrue. If the preconditions are not met, then
+// the results are determined by ResultsIfFalse.
+//
+// If Preconditions == NOCOND, then results in ResultsIfTrue are unconditional and ResultsIfFalse
+// is ignored
+//
+typedef struct _X86_OPCODE
+{
+ struct _X86_OPCODE *Table;
+ CPU_TYPE CPU; // minimum CPU (starting with i386)
+ U32 MnemonicFlags;
+ char Mnemonic[X86_MAX_INSTRUCTION_LEN+1];
+ U32 OperandFlags[X86_MAX_OPERANDS];
+ U32 Preconditions;
+ U32 FlagsChanged; // changes in flags
+ U32 ResultsIfTrue; // results if Preconditions are met
+ U32 ResultsIfFalse; // results if Preconditions are not met
+} X86_OPCODE;
+
+typedef struct _X86_INSTRUCTION
+{
+ struct _INSTRUCTION *Instruction; // the generic instruction format representing this instruction
+
+ X86_OPCODE Opcode;
+
+ U8 sib_b;
+ U8 modrm_b;
+ MODRM modrm;
+ SIB sib;
+ U8 rex_b;
+ REX rex;
+ REX_MODRM rex_modrm;
+ REX_SIB rex_sib;
+
+ X86_SEGMENT DstSegment;
+ union
+ {
+ X86_SEGMENT Segment;
+ DWORD Selector;
+ };
+
+ // NOTE: these are for internal use, use Instruction->Operands[]
+ //
+ // If DstRegAddressing or SrcRegAddressing = TRUE then BaseRegister is the base register
+ // It is the operand represented by SIBOperand
+ //
+ // The operand indices of the destination operands is in DstOpIndex[0 to DstOpCount-1]
+ // The operand indices of the source operands is in SrcOpIndex[0 to SrcOpCount-1]
+ //
+ // These are used both for instructions like xadd/xchg (where both operands are source/destination)
+ // and to represent implicit registers (e.g., cmpxchg)
+
+ U8 SrcOpIndex[3];
+ U8 DstOpIndex[3];
+
+ // Addressing mode:
+ // If DstRegAddressing = TRUE, then these apply to DstReg
+ // If SrcRegAddressing = TRUE, then this applies to SrcReg[AddressIndex]
+ // If both are false, then SrcReg and DstReg are not addresses
+ X86_REGISTER BaseRegister;
+ X86_REGISTER IndexRegister;
+
+ U8 Scale;
+ U8 HasDefault64Operand : 1;
+ U8 HasOperandSizePrefix : 1;
+ U8 HasAddressSizePrefix : 1;
+ U8 HasSegmentOverridePrefix : 1;
+ U8 HasLockPrefix : 1;
+ U8 HasRepeatWhileEqualPrefix : 1;
+ U8 HasRepeatWhileNotEqualPrefix : 1;
+ U8 HasBranchTakenPrefix : 1;
+ U8 HasBranchNotTakenPrefix : 1;
+ U8 HasDstAddressing : 1;
+ U8 HasSrcAddressing : 1;
+ U8 HasModRM : 1;
+ U8 HasBaseRegister : 1;
+ U8 HasIndexRegister : 1;
+ U8 HasFullDisplacement : 1;
+ U8 HasDstSegment : 1; // used for ins/cmps/scas/movs/etc which have 2 segments
+ U8 DstAddressIndex : 2; // DstOpIndex[DstAddressIndex]
+ U8 SrcAddressIndex : 2; // SrcOpIndex[SrcAddressIndex]
+ U8 DstOpCount : 2;
+ U8 SrcOpCount : 2;
+ U8 OperandSize : 4;
+ U8 AddressSize : 4;
+ U8 Relative : 1;
+ U8 HasSelector : 1; // segment is actually a selector
+ U8 Group : 5;
+
+ S64 Displacement;
+
+} X86_INSTRUCTION;
+
+////////////////////////////////////////////////////////////////////////////////////
+// Exported functions
+////////////////////////////////////////////////////////////////////////////////////
+
+extern ARCHITECTURE_FORMAT_FUNCTIONS X86;
+
+// Instruction setup
+BOOL X86_InitInstruction(struct _INSTRUCTION *Instruction);
+void X86_CloseInstruction(struct _INSTRUCTION *Instruction);
+
+// Instruction translator
+BOOL X86_TranslateInstruction(struct _INSTRUCTION *Instruction, BOOL Verbose);
+
+// Instruction decoder
+BOOL X86_GetInstruction(struct _INSTRUCTION *Instruction, U8 *Address, U32 Flags);
+
+// Function finding
+U8 *X86_FindFunctionByPrologue(struct _INSTRUCTION *Instruction, U8 *StartAddress, U8 *EndAddress, U32 Flags);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // X86_DISASM_H
+
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86_tables.h b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86_tables.h
new file mode 100644
index 0000000..9ddb3f4
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/disasm_x86_tables.h
@@ -0,0 +1,3654 @@
+// Copyright (C) 2004, Matt Conover (mconover@gmail.com)
+//
+// The opcode tables in this file are based off the Intel Instruction Set Reference
+// and an assortment of disassemblers, primarily libdisasm (by mammon)
+
+#ifndef DISASM_X86_TABLES
+#define DISASM_X86_TABLES
+
+#define X86_GET_REG(val) ((val) & 7)
+#define X86_GET_REG64(val) ((GET_REX_B(X86Instruction->rex_b) << 3) | ((val) & 7))
+
+#define GET_MODRM_MOD(a) (((a) >> 6) & 3) // bits 6, 7
+#define GET_MODRM_REG(a) (((a) >> 3) & 7) // bits 3, 4, 5
+#define GET_MODRM_EXT(a) (((a) >> 3) & 7) // bits 3, 4, 5
+#define GET_MODRM_RM(a) ((a) & 7) // bits 0, 1, 2
+
+#define GET_SIB_SCALE(a) (((a) >> 6) & 3) // bits 6, 7
+#define GET_SIB_INDEX(a) (((a) >> 3) & 7) // bits 3, 4, 5
+#define GET_SIB_BASE(a) ((a) & 7) // bits 0, 1, 2
+
+#define REX_PREFIX_START 0x40
+#define REX_PREFIX_END 0x4F
+#define GET_REX_W(r) (((r) & 8) >> 3) // bit 3
+#define GET_REX_R(r) (((r) & 4) >> 2) // bit 2
+#define GET_REX_X(r) (((r) & 2) >> 1) // bit 1
+#define GET_REX_B(r) ((r) & 1) // bit 0
+#define REX_MASK(n) ((n >> 16) & 0x0F) // bits 0-3
+
+// Groupings to make the opcode table more readible
+#define NOARGS { 0, 0, 0 }
+#define NOCOND 0
+#define NOGROUP NULL
+#define NOACTION 0
+#define NOCHANGE 0
+#define IGNORED 0
+#define NOINSTR NOGROUP, CPU_UNKNOWN, 0, "", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED
+#define GROUP CPU_UNKNOWN, 0, "", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED
+#define PREFIX NOGROUP, CPU_UNKNOWN, ITYPE_EXT_PREFIX, "", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED
+#define EXT_FPU CPU_UNKNOWN, ITYPE_EXT_FPU, "", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED
+#define EXT_64 CPU_UNKNOWN, ITYPE_EXT_64, "", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED
+#define EXT_SUFFIX(a, b, c) CPU_UNKNOWN, ITYPE_EXT_SUFFIX, "", { a, b, c }, NOCOND, NOCHANGE, NOACTION, IGNORED
+#define EXT_MODRM CPU_UNKNOWN, ITYPE_EXT_MODRM, "", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED
+
+#define SET_MODRM(modrm, src) \
+{ \
+ (modrm).mod = GET_MODRM_MOD(src); \
+ (modrm).reg = GET_MODRM_REG(src); \
+ (modrm).rm = GET_MODRM_RM(src); \
+}
+
+#define SET_REX_MODRM(rex_modrm, rex, modrm) \
+{ \
+ (rex_modrm).rm = ((rex).b << 3) | (modrm).rm; \
+ (rex_modrm).reg = ((rex).r << 3) | (modrm).reg; \
+}
+
+#define SET_SIB(sib, src) \
+{ \
+ (sib).scale = GET_SIB_SCALE(src); \
+ (sib).index = GET_SIB_INDEX(src); \
+ (sib).base = GET_SIB_BASE(src); \
+}
+
+#define SET_REX_SIB(rex_sib, rex, sib) \
+{ \
+ (rex_sib).index = ((rex).x << 3) | (sib).index; \
+ (rex_sib).base = ((rex).b << 3) | (sib).base; \
+}
+
+#define SET_REX(rex, src) \
+{ \
+ (rex).w = GET_REX_W(src); \
+ (rex).r = GET_REX_R(src); \
+ (rex).x = GET_REX_X(src); \
+ (rex).b = GET_REX_B(src); \
+}
+
+// Addressing modes
+#define AMODE_A 0x00010000
+#define AMODE_C 0x00020000
+#define AMODE_D 0x00030000
+#define AMODE_E 0x00040000
+#define AMODE_G 0x00050000
+#define AMODE_I 0x00060000
+#define AMODE_J 0x00070000
+#define AMODE_M 0x00080000
+#define AMODE_O 0x00090000
+#define AMODE_P 0x000A0000
+#define AMODE_Q 0x000B0000
+#define AMODE_R 0x000C0000
+#define AMODE_S 0x000D0000
+#define AMODE_T 0x000E0000
+#define AMODE_V 0x000F0000
+#define AMODE_W 0x00100000
+#define AMODE_X 0x00110000
+#define AMODE_Y 0x00120000
+#define AMODE_PR 0x00130000
+#define AMODE_VR 0x00140000
+#define AMODE_xlat 0x00150000
+
+// Operand types
+#define OPTYPE_a 0x01000000
+#define OPTYPE_b 0x02000000
+#define OPTYPE_d 0x03000000
+#define OPTYPE_p 0x04000000
+#define OPTYPE_q 0x05000000
+#define OPTYPE_dt 0x06000000
+#define OPTYPE_v 0x07000000
+#define OPTYPE_w 0x08000000
+#define OPTYPE_ps 0x09000000 // packed 128-bit single real
+#define OPTYPE_pd 0x0A000000 // packed 128-bit double real
+#define OPTYPE_pb 0x0B000000 // packed BCD (10 bytes, 18-bit precision)
+#define OPTYPE_ss 0x0C000000 // scalar single real
+#define OPTYPE_sd 0x0D000000 // scalar double real
+#define OPTYPE_se 0x0E000000 // scalar extended real
+#define OPTYPE_fev 0x0F000000 // FPU environment (28 bytes if 32-bit modes, 14 bytes in 16-bit mode)
+#define OPTYPE_fst1 0x10000000 // FPU state (108 bytes in 32-bit modes, 94 bytes in 16-bit real mode)
+#define OPTYPE_fst2 0x11000000 // FPU/MMX/XMM/MXCSR state (512 bytes)
+#define OPTYPE_z 0x12000000
+#define OPTYPE_o 0x13000000
+#define OPTYPE_dq 0x14000000 // OPTYPE_d or OPTYPE_o
+#define OPTYPE_mw 0x15000000 // word if memory, register size otherwise
+#define OPTYPE_sso 0x16000000 // OPTYPE_ss or OPTYPE_o
+#define OPTYPE_sdo 0x17000000 // OPTYPE_ss or OPTYPE_o
+#define OPTYPE_cpu 0x18000000 // pointer to CPU state structure
+#define OPTYPE_lea 0x19000000 // size set by other operand
+// NOTE: if you change this, you must also update OptypeHandlers[] in disasm_x86.c
+// Be sure to preserve the ordering
+
+//////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// Registers
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+static char *Addressing16[8] = {"bx+si","bx+di","bp+si","bp+di","si","di","bp","bx"};
+static char *MMX_Registers[8] = {"mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7"};
+static char *SSE_Registers[8] = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"};
+static char *DR_Registers[8] = {"dr0", "dr1", "dr2", "dr3", "dr4", "dr5", "dr6", "dr7"};
+static char *CR_Registers[8] = {"cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7"};
+static char *TR_Registers[8] = {"tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7"};
+static char *FPU_Registers[8] = {"st(0)", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)"};
+static char *Segments[8] = {"es", "cs", "ss", "ds", "fs", "gs", "ERROR", "ERROR"};
+static char *Registers8[8] = {"al", "cl", "dl", "bl", "ah", "ch", "dh", "bh" };
+static char *Registers16[8] = {"ax", "cx", "dx", "bx", "sp", "bp", "si", "di" };
+static char *Registers32[8] = {"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" };
+static char *REX_Registers8[16] = {"al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" };
+static char *REX_Registers16[16] = {"ax", "cx", "dx", "bx", "sp", "bp", "si", "di", "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" };
+static char *REX_Registers32[16] = {"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" };
+static char *REX_Registers64[16] = {"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" };
+static char *DataSizes[8+1] = {"byte ptr", "word ptr", "dword ptr", "6_byte ptr", "qword ptr", "10_byte ptr", "INVALID PTR", "INVALID PTR", "oword ptr"};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// FPU constants
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+BYTE float_0[10] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+BYTE float_1[10] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x3F };
+BYTE float_l2t[10] = { 0xFE, 0x8A, 0x1B, 0xCD, 0x4B, 0x78, 0x9A, 0xD4, 0x00, 0x40 };
+BYTE float_l2e[10] = { 0xBC, 0xF0, 0x17, 0x5C, 0x29, 0x3B, 0xAA, 0xB8, 0xFF, 0x3F };
+BYTE float_pi[10] = { 0x35, 0xC2, 0x68, 0x21, 0xA2, 0xDA, 0x0F, 0xC9, 0x00, 0x40 };
+BYTE float_lg2[10] = { 0x99, 0xF7, 0xCF, 0xFB, 0x84, 0x9A, 0x20, 0x9A, 0xFD, 0x3F };
+BYTE float_ln2[10] = { 0xAC, 0x79, 0xCF, 0xD1, 0xF7, 0x17, 0x72, 0xB1, 0xFE, 0x3F };
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// Tables
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+extern X86_OPCODE X86_Opcodes_2[0x100];
+extern X86_OPCODE X86_Group_1_80[8], X86_Group_1_81[8], X86_Group_1_82[8], X86_Group_1_83[8], X86_Group_2_C0[8], X86_Group_2_C1[8], X86_Group_2_D0[8], X86_Group_2_D1[8], X86_Group_2_D2[8], X86_Group_2_D3[8], X86_Group_3_F6[8], X86_Group_3_F7[8], X86_Group_4[8], X86_Group_5[8], X86_Group_6[8], X86_Group_7[8], X86_Group_8[8], X86_Group_9[8], X86_Group_10[8], X86_Group_11[8], X86_Group_12_C6[8], X86_Group_12_C7[8], X86_Group_13[8], X86_Group_14[8], X86_Group_15[8], X86_Group_16[8], X86_Group_17[8], X86_Group_P[8];
+extern X86_OPCODE X86_SSE[0x300], X86_SSE2_Group_13[24], X86_SSE2_Group_14[24], X86_SSE2_Group_15[24];
+extern X86_OPCODE X86_ESC_0[0x48], X86_ESC_1[0x48], X86_ESC_2[0x48], X86_ESC_3[0x48], X86_ESC_3[0x48], X86_ESC_4[0x48], X86_ESC_5[0x48], X86_ESC_6[0x48], X86_ESC_7[0x48];
+extern X86_OPCODE X86_3DNOW_0F[0x100];
+extern X86_OPCODE X86_0F01_ModRM[0x100];
+extern X86_OPCODE X86_Opcode_63[2], X86_Opcode_0F05[2];
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// Opcode tables
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+X86_OPCODE X86_Opcodes_1[0x100] = // 1 byte opcodes
+{
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OPTYPE_ES | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OPTYPE_ES | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x08 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x09 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x0A */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x0B */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x0C */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x0D */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OPTYPE_CS | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x0E */
+ { X86_Opcodes_2, GROUP }, /* 0x0F */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x10 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x11 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x12 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x13 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x14 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x15 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OPTYPE_SS | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x16 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OPTYPE_SS | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x17 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x18 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x19 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x1A */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x1B */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x1C */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x1D */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OPTYPE_DS | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x1E */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OPTYPE_DS | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x1F */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x20 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x21 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x22 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x23 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x24 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x25 */
+ { PREFIX }, /* 0x26 */
+ { NOGROUP, CPU_I386, ITYPE_BCDCONV, "daa", { OPTYPE_REG_AL | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_AF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x27 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x28 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x29 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x2A */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x2B */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x2C */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x2D */
+ { PREFIX }, /* 0x2E */
+ { NOGROUP, CPU_I386, ITYPE_BCDCONV, "das", { OPTYPE_REG_AL | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_AF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x2F */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x30 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x31 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x32 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x33 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x34 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x35 */
+ { PREFIX }, /* 0x36 */
+ { NOGROUP, CPU_I386, ITYPE_BCDCONV, "aaa", { OPTYPE_REG_AL | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_AF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x37 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_E | OPTYPE_b | OP_SRC, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x38 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x39 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_G | OPTYPE_b | OP_SRC, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x3A */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_G | OPTYPE_v | OP_SRC, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x3B */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { OPTYPE_REG_AL | OP_SIGNED | OP_SRC, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x3C */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { OPTYPE_REG_xAX_BIG | OP_SIGNED | OP_SRC, AMODE_I | OPTYPE_z | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x3D */
+ { PREFIX }, /* 0x3E */
+ { NOGROUP, CPU_I386, ITYPE_BCDCONV, "aas", { OPTYPE_REG_AL | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_AF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x3F */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x40 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x41 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x42 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x43 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x44 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x45 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x46 */
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x47 */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x48 */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x49 */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x4A */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x4B */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x4C */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x4D */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x4E */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x4F */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x50 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x51 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x52 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x53 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x54 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x55 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x56 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OP_REG | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x57 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x58 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x59 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5A */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5B */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5C */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5D */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5E */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OP_REG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5F */
+ { NOGROUP, CPU_I386, ITYPE_PUSHA, "pushad", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x60 */
+ { NOGROUP, CPU_I386, ITYPE_POPA, "popad", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x61 */
+ { NOGROUP, CPU_I386, ITYPE_BOUNDS, "bound", { AMODE_G | OPTYPE_v | OP_SRC, AMODE_M | OPTYPE_a | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x62 */
+ { X86_Opcode_63, EXT_64 }, /* 0x63 */
+ { PREFIX }, /* 0x64 */
+ { PREFIX }, /* 0x65 */
+ { PREFIX }, /* 0x66 */
+ { PREFIX }, /* 0x67 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { AMODE_I | OPTYPE_z | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x68 */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "imul", { AMODE_G | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, AMODE_I | OPTYPE_z | OP_SIGNED | OP_SRC }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x69 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x6A */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "imul", { AMODE_G | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x6B */
+ { NOGROUP, CPU_I386, ITYPE_IN, "insb", { AMODE_Y | OPTYPE_b | OP_DST, OPTYPE_REG_DX | OP_SYS | OP_SRC, 0 }, COND_D, NOCHANGE, xDI_DEC | xCX_REP_DEC, xDI_INC | xCX_REP_DEC }, /* 0x6C */
+ { NOGROUP, CPU_I386, ITYPE_IN, "insd", { AMODE_Y | OPTYPE_z | OP_DST, OPTYPE_REG_DX | OP_SYS | OP_SRC, 0 }, COND_D, NOCHANGE, xDI_DECx | xCX_REP_DEC, xDI_INCx | xCX_REP_DEC }, /* 0x6D */
+ { NOGROUP, CPU_I386, ITYPE_OUT, "outsb", { OPTYPE_REG_DX | OP_SYS | OP_DST, AMODE_X | OPTYPE_b | OP_SRC, 0 }, COND_D, NOCHANGE, xSI_DEC | xCX_REP_DEC, xSI_INC | xCX_REP_DEC }, /* 0x6E */
+ { NOGROUP, CPU_I386, ITYPE_OUT, "outsd", { OPTYPE_REG_DX | OP_SYS | OP_DST, AMODE_X | OPTYPE_z | OP_SRC, 0 }, COND_D, NOCHANGE, xSI_DECx | xCX_REP_DEC, xSI_INCx | xCX_REP_DEC}, /* 0x6F */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jo", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_O, NOCHANGE, OP1_DST, NOACTION }, /* 0x70 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jno", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NO, NOCHANGE, OP1_DST, NOACTION }, /* 0x71 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jb", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_C, NOCHANGE, OP1_DST, NOACTION }, /* 0x72 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jnb", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NC, NOCHANGE, OP1_DST, NOACTION }, /* 0x73 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jz", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_Z, NOCHANGE, OP1_DST, NOACTION }, /* 0x74 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jnz", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NZ, NOCHANGE, OP1_DST, NOACTION }, /* 0x75 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jbe", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_BE, NOCHANGE, OP1_DST, NOACTION }, /* 0x76 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "ja", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_A, NOCHANGE, OP1_DST, NOACTION }, /* 0x77 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "js", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_S, NOCHANGE, OP1_DST, NOACTION }, /* 0x78 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jns", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NS, NOCHANGE, OP1_DST, NOACTION }, /* 0x79 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jpe", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_PE, NOCHANGE, OP1_DST, NOACTION }, /* 0x7A */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jpo", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_PO, NOCHANGE, OP1_DST, NOACTION }, /* 0x7B */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jl", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_L, NOCHANGE, OP1_DST, NOACTION }, /* 0x7C */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jge", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_GE, NOCHANGE, OP1_DST, NOACTION }, /* 0x7D */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jle", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_LE, NOCHANGE, OP1_DST, NOACTION }, /* 0x7E */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jg", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_G, NOCHANGE, OP1_DST, NOACTION }, /* 0x7F */
+ { X86_Group_1_80, GROUP }, /* 0x80 Eb Ib */
+ { X86_Group_1_81, GROUP }, /* 0x81 Ev Iz */
+ { X86_Group_1_82, GROUP }, /* 0x82 Eb Ib */
+ { X86_Group_1_83, GROUP }, /* 0x83 Ev Ib */
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { AMODE_E | OPTYPE_b | OP_SRC, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x84 */
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x85 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { AMODE_E | OPTYPE_b | OP_SRC | OP_DST, AMODE_G | OPTYPE_b | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x86 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, AMODE_G | OPTYPE_v | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x87 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_E | OPTYPE_b | OP_DST, AMODE_G | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x88 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x89 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_G | OPTYPE_b | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x8A */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x8B */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_E | OPTYPE_mw | OP_DST, AMODE_S | OPTYPE_w | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x8C */
+ { NOGROUP, CPU_I386, ITYPE_LEA, "lea", { AMODE_G | OPTYPE_v | OP_DST, AMODE_M | OPTYPE_lea | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x8D */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_S | OPTYPE_w | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x8E */
+ { X86_Group_10, GROUP }, /* 0x8F */
+ { NOGROUP, CPU_I386, ITYPE_NOP, "nop", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x90 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x91 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x92 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x93 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x94 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x95 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x96 */
+ { NOGROUP, CPU_I386, ITYPE_XCHG, "xchg", { OPTYPE_REG_xAX_BIG | OP_SRC | OP_DST, OP_REG | OP_SRC | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x97 */
+ { NOGROUP, CPU_I386, ITYPE_SZCONV, "cwde", { OPTYPE_REG_xAX_BIG | OP_SIGNED | OP_DST, OPTYPE_REG_xAX_SMALL | OP_SIGNED | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x98 */
+ { NOGROUP, CPU_I386, ITYPE_SZCONV, "cdq", { OPTYPE_xDX_HI_xAX_LO | OP_SIGNED | OP_DST, OPTYPE_REG_xAX_BIG | OP_SIGNED | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x99 */
+ { NOGROUP, CPU_I386, ITYPE_CALL, "call", { AMODE_A | OPTYPE_p | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x9A */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "wait", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x9B */
+ { NOGROUP, CPU_I386, ITYPE_PUSHF, "pushf", { OPTYPE_xFLAGS | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x9C */
+ { NOGROUP, CPU_I386, ITYPE_POPF, "popf", { OPTYPE_xFLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_ALL_MOD, NOACTION, IGNORED }, /* 0x9D */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "sahf", { OPTYPE_FLAGS | OP_DST, OPTYPE_REG_AH | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_AF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x9E */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "lahf", { OPTYPE_REG_AH | OP_DST, OPTYPE_FLAGS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x9F */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG_AL | OP_DST, AMODE_O | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA0 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_O | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA1 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_O | OPTYPE_b | OP_DST, OPTYPE_REG_AL | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA2 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_O | OPTYPE_v | OP_DST, OPTYPE_REG_xAX_BIG | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA3 */
+ { NOGROUP, CPU_I386, ITYPE_STRMOV, "movsb", { AMODE_Y | OPTYPE_b | OP_DST, AMODE_X | OPTYPE_b | OP_SRC, 0 }, COND_D, NOCHANGE, xDI_DEC | xSI_DEC | xCX_REP_DEC, xDI_INC | xSI_INC | xCX_REP_DEC}, /* 0xA4 */
+ { NOGROUP, CPU_I386, ITYPE_STRMOV, "movsd", { AMODE_Y | OPTYPE_z | OP_DST, AMODE_X | OPTYPE_z | OP_SRC, 0 }, COND_D, NOCHANGE, xDI_DECx | xSI_DECx| xCX_REP_DEC, xDI_INCx | xSI_INCx | xCX_REP_DEC }, /* 0xA5 */
+ { NOGROUP, CPU_I386, ITYPE_STRCMP, "cmpsb", { AMODE_X | OPTYPE_b | OP_SRC, AMODE_Y | OPTYPE_b | OP_SRC, 0 }, COND_D, FLAG_COMMON_MOD, xDI_DEC | xSI_DEC | xCX_REP_DEC, xDI_INC | xSI_INC | xCX_REP_DEC }, /* 0xA6 */
+ { NOGROUP, CPU_I386, ITYPE_STRCMP, "cmpsd", { AMODE_X | OPTYPE_z | OP_SRC, AMODE_Y | OPTYPE_z | OP_SRC, 0 }, COND_D, FLAG_COMMON_MOD, xDI_DECx | xSI_DECx | xCX_REP_DEC, xDI_INCx | xSI_INCx | xCX_REP_DEC}, /* 0xA7 */
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { OPTYPE_REG_AL | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0xA8 */
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { OPTYPE_REG_xAX_BIG | OP_SRC, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0xA9 */
+ { NOGROUP, CPU_I386, ITYPE_STRSTOR, "stosb", { AMODE_Y | OPTYPE_b | OP_DST, OPTYPE_REG_AL | OP_SRC, 0 }, COND_D, NOCHANGE, xDI_DEC | xSI_DEC | xCX_REP_DEC, xDI_INC | xSI_INC | xCX_REP_DEC }, /* 0xAA */
+ { NOGROUP, CPU_I386, ITYPE_STRSTOR, "stosd", { AMODE_Y | OPTYPE_z | OP_DST, OPTYPE_REG_xAX_BIG | OP_SRC, 0 }, COND_D, NOCHANGE, xDI_DECx | xSI_DECx | xCX_REP_DEC, xDI_INCx | xSI_INCx | xCX_REP_DEC }, /* 0xAB */
+ { NOGROUP, CPU_I386, ITYPE_STRLOAD, "lodsb", { OPTYPE_REG_AL | OP_DST, AMODE_X | OPTYPE_b | OP_SRC, 0 }, COND_D, NOCHANGE, xSI_DEC | xCX_REP_DEC, xSI_INC | xCX_REP_DEC }, /* 0xAC */
+ { NOGROUP, CPU_I386, ITYPE_STRLOAD, "lodsd", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_X | OPTYPE_z | OP_SRC, 0 }, COND_D, NOCHANGE, xSI_DECx | xCX_REP_DEC, xSI_INCx | xCX_REP_DEC }, /* 0xAD */
+ { NOGROUP, CPU_I386, ITYPE_STRCMP, "scasb", { OPTYPE_REG_AL | OP_SRC, AMODE_Y | OPTYPE_b | OP_SRC, 0 }, COND_D, FLAG_COMMON_MOD, xDI_DEC | xCX_REP_DEC, xDI_INC | xCX_REP_DEC }, /* 0xAE */
+ { NOGROUP, CPU_I386, ITYPE_STRCMP, "scasd", { OPTYPE_REG_xAX_BIG | OP_SRC, AMODE_Y | OPTYPE_z | OP_SRC, 0 }, COND_D, FLAG_COMMON_MOD, xDI_DECx, xDI_INCx }, /* 0xAF */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB0 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB1 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB2 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB3 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB4 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB5 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB6 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OPTYPE_REG8 | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB7 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB8 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB9 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBA */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBB */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBC */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBD */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBE */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { OP_REG | OP_DST, AMODE_I | OPTYPE_v | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBF */
+ { X86_Group_2_C0, GROUP }, /* 0xC0 Eb Ib */
+ { X86_Group_2_C1, GROUP }, /* 0xC1 Ev Ib */
+ { NOGROUP, CPU_I386, ITYPE_RET, "ret", { AMODE_I | OPTYPE_w | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC2 */
+ { NOGROUP, CPU_I386, ITYPE_RET, "ret", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC3 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "les", { AMODE_G | OPTYPE_z | OP_DST, AMODE_M | OPTYPE_p | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC4 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "lds", { AMODE_G | OPTYPE_z | OP_DST, AMODE_M | OPTYPE_p | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC5 */
+ { X86_Group_12_C6, GROUP }, /* 0xC6 Eb Ib */
+ { X86_Group_12_C7, GROUP }, /* 0xC7 Ev Iz */
+ { NOGROUP, CPU_I386, ITYPE_ENTER, "enter", { OPTYPE_REG_xBP | OP_SRC | OP_DST, AMODE_I | OPTYPE_w | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC8 */
+ { NOGROUP, CPU_I386, ITYPE_LEAVE, "leave", { OPTYPE_REG_xBP | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC9 */
+ { NOGROUP, CPU_I386, ITYPE_RET, "retf", { AMODE_I | OPTYPE_w | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCA */
+ { NOGROUP, CPU_I386, ITYPE_RET, "retf", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCB */
+ { NOGROUP, CPU_I386, ITYPE_DEBUG, "int3", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCC */
+ { NOGROUP, CPU_I386, ITYPE_TRAP, "int", { AMODE_I | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCD */
+ { NOGROUP, CPU_I386, ITYPE_OFLOW, "into", NOARGS, NOCOND, NOCHANGE, NOACTION, NOACTION }, /* 0xCE */
+ { NOGROUP, CPU_I386, ITYPE_TRAPRET, "iret", NOARGS, NOCOND, FLAG_ALL_MOD, NOACTION, IGNORED }, /* 0xCF */
+ { X86_Group_2_D0, GROUP }, /* 0xD0 Eb, 1 */
+ { X86_Group_2_D1, GROUP }, /* 0xD1 Ev, 1 */
+ { X86_Group_2_D2, GROUP }, /* 0xD2 Eb, CL */
+ { X86_Group_2_D3, GROUP }, /* 0xD3 Ev, CL */
+ { NOGROUP, CPU_I386, ITYPE_BCDCONV, "aam", { OPTYPE_REG_AX | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD, NOACTION, IGNORED }, /* 0xD4 */
+ { NOGROUP, CPU_I386, ITYPE_BCDCONV, "aad", { OPTYPE_REG_AX | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD, NOACTION, IGNORED }, /* 0xD5 */
+ { NOGROUP, CPU_I386, ITYPE_ARITH, "salc", { OPTYPE_REG_AL | OP_DST, OPTYPE_FF | OP_SRC, OPTYPE_0 | OP_SRC }, COND_C, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0xD6 */
+ { NOGROUP, CPU_I386, ITYPE_XLAT, "xlat", { OPTYPE_REG_AL | OP_DST, AMODE_xlat | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD7 */
+ { X86_ESC_0, EXT_FPU }, /* 0xD8 */
+ { X86_ESC_1, EXT_FPU }, /* 0xD9 */
+ { X86_ESC_2, EXT_FPU }, /* 0xDA */
+ { X86_ESC_3, EXT_FPU }, /* 0xDB */
+ { X86_ESC_4, EXT_FPU }, /* 0xDC */
+ { X86_ESC_5, EXT_FPU }, /* 0xDD */
+ { X86_ESC_6, EXT_FPU }, /* 0xDE */
+ { X86_ESC_7, EXT_FPU }, /* 0xDF */
+ { NOGROUP, CPU_I386, ITYPE_LOOPCC, "loopnz", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_REG_xCX_BIG_NZ | COND_NZ, NOCHANGE, OP1_DST | xCX_DEC, NOACTION }, /* 0xE0 */
+ { NOGROUP, CPU_I386, ITYPE_LOOPCC, "loopz", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_REG_xCX_BIG_NZ | COND_Z, NOCHANGE, OP1_DST | xCX_DEC, NOACTION }, /* 0xE1 */
+ { NOGROUP, CPU_I386, ITYPE_LOOPCC, "loop", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_REG_xCX_BIG_NZ, NOCHANGE, OP1_DST | xCX_DEC, NOACTION }, /* 0xE2 */
+ { NOGROUP, CPU_I386, ITYPE_LOOPCC, "jecxz", { AMODE_J | OPTYPE_b | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_REG_xCX_BIG_Z, NOCHANGE, OP1_DST, NOACTION }, /* 0xE3 */
+ { NOGROUP, CPU_I386, ITYPE_IN, "in", { OPTYPE_REG_AL | OP_DST, AMODE_I | OPTYPE_b | OP_SYS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, NOACTION }, /* 0xE4 */
+ { NOGROUP, CPU_I386, ITYPE_IN, "in", { OPTYPE_REG_xAX_BIG | OP_DST, AMODE_I | OPTYPE_b | OP_SYS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, NOACTION }, /* 0xE5 */
+ { NOGROUP, CPU_I386, ITYPE_OUT, "out", { AMODE_I | OPTYPE_b | OP_SYS | OP_DST, OPTYPE_REG_AL | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, NOACTION }, /* 0xE6 */
+ { NOGROUP, CPU_I386, ITYPE_OUT, "out", { AMODE_I | OPTYPE_b | OP_SYS | OP_DST, OPTYPE_REG_xAX_BIG | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, NOACTION }, /* 0xE7 */
+ { NOGROUP, CPU_I386, ITYPE_CALL, "call", { AMODE_J | OPTYPE_z | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE8 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCH, "jmp", { AMODE_J | OPTYPE_z | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE9 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCH, "jmp", { AMODE_A | OPTYPE_p | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEA */
+ { NOGROUP, CPU_I386, ITYPE_BRANCH, "jmp", { AMODE_J | OPTYPE_b | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEB */
+ { NOGROUP, CPU_I386, ITYPE_IN, "in", { OPTYPE_REG_AL | OP_DST, OPTYPE_REG_DX | OP_SYS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEC */
+ { NOGROUP, CPU_I386, ITYPE_IN, "in", { OPTYPE_REG_xAX_BIG | OP_DST, OPTYPE_REG_DX | OP_SYS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xED */
+ { NOGROUP, CPU_I386, ITYPE_OUT, "out", { OPTYPE_REG_DX | OP_SYS | OP_DST, OPTYPE_REG_AL | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEE */
+ { NOGROUP, CPU_I386, ITYPE_OUT, "out", { OPTYPE_REG_DX | OP_SYS | OP_DST, OPTYPE_REG_xAX_BIG | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEF */
+ { PREFIX }, /* 0xF0 */
+ { NOGROUP, CPU_I386, ITYPE_DEBUG, "int1", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, // aka icebp /* 0xF1 */
+ { PREFIX }, /* 0xF2 */
+ { PREFIX }, /* 0xF3 */
+ { NOGROUP, CPU_I386, ITYPE_HALT, "hlt", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF4 */
+ { NOGROUP, CPU_I386, ITYPE_TOGCF, "cmc", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_CF_TOG, IGNORED }, /* 0xF5 */
+ { X86_Group_3_F6, GROUP }, /* 0xF6 Eb */
+ { X86_Group_3_F7, GROUP }, /* 0xF7 Ev */
+ { NOGROUP, CPU_I386, ITYPE_CLEARCF, "clc", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_CF_CLR, NOACTION, IGNORED }, /* 0xF8 */
+ { NOGROUP, CPU_I386, ITYPE_SETCF, "stc", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_CF_SET, NOACTION, IGNORED }, /* 0xF9 */
+ { NOGROUP, CPU_I386, ITYPE_CLEARIF, "cli", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_IF_CLR, NOACTION, IGNORED }, /* 0xFA */
+ { NOGROUP, CPU_I386, ITYPE_SETIF, "sti", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_IF_SET, NOACTION, IGNORED }, /* 0xFB */
+ { NOGROUP, CPU_I386, ITYPE_CLEARDF, "cld", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_DF_CLR, NOACTION, IGNORED }, /* 0xFC */
+ { NOGROUP, CPU_I386, ITYPE_SETDF, "std", { OPTYPE_FLAGS | OP_DST, 0, 0 }, NOCOND, FLAG_DF_SET, NOACTION, IGNORED }, /* 0xFD */
+ { X86_Group_4, GROUP }, /* 0xFE */
+ { X86_Group_5, GROUP }, /* 0xFF */
+};
+
+X86_OPCODE X86_Opcodes_2[0x100] = // 2 byte opcodes
+{
+ { X86_Group_6, GROUP }, /* 0x00 */
+ { X86_0F01_ModRM, EXT_MODRM }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "lar", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "lsl", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { X86_Opcode_0F05, EXT_64 }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "clts", { OPTYPE_CR0 | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_SYSCALLRET, "sysret", { OPTYPE_STAR_MSR | OP_MSR | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+ // 0F 07 could also be this undocumented instruction on older CPUs:
+ // { NOGROUP, CPU_I386, ITYPE_SYSTEM, "loadall", { AMODE_Y | OPTYPE_cpu | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+ { NOGROUP, CPU_I486, ITYPE_SYSTEM, "invd", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x08 */
+ { NOGROUP, CPU_I486, ITYPE_SYSTEM, "wbinvd", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x09 */
+ { NOINSTR }, /* 0x0A */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_INVALID, "undef" /* aka UD2 */, NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x0B */
+ { NOINSTR }, /* 0x0C */
+ { X86_Group_P, GROUP }, /* 0x0D */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "femms", { OPTYPE_FPU_TAG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x0E */
+ { X86_3DNOW_0F, EXT_SUFFIX(AMODE_P | OPTYPE_q, AMODE_Q | OPTYPE_q, 0) }, /* 0x0F */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movups", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x10 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movups", { AMODE_W | OPTYPE_ps | OP_DST, AMODE_V | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x11 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movlps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x12 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movlps", { AMODE_M | OPTYPE_q | OP_DST, AMODE_V | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x13 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "unpcklps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x14 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "unpckhps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x15 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movhps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x16 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movhps", { AMODE_M | OPTYPE_q | OP_DST, AMODE_V | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x17 */
+ { X86_Group_17, GROUP }, /* 0x18 */
+ { NOINSTR }, /* 0x19 */
+ { NOINSTR }, /* 0x1A */
+ { NOINSTR }, /* 0x1B */
+ { NOINSTR }, /* 0x1C */
+ { NOINSTR }, /* 0x1D */
+ { NOINSTR }, /* 0x1E */
+ { NOINSTR }, /* 0x1F */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_R | OPTYPE_dq | OP_DST, AMODE_C | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x20 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_R | OPTYPE_dq | OP_DST, AMODE_D | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x21 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_C | OPTYPE_dq | OP_DST, AMODE_R | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x22 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_D | OPTYPE_dq | OP_DST, AMODE_R | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x23 */
+ { NOINSTR }, /* 0x24 */
+ //{ NOGROUP, CPU_I486, ITYPE_MOV, "mov", { AMODE_R | OPTYPE_d | OP_DST, AMODE_T | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x24 */
+ { NOINSTR }, /* 0x25 */
+ { NOINSTR }, /* 0x26 */
+ //{ NOGROUP, CPU_I486, ITYPE_MOV, "mov", { AMODE_T | OPTYPE_d | OP_DST, AMODE_R | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x26 */
+ { NOINSTR }, /* 0x27 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movaps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x28 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movaps", { AMODE_W | OPTYPE_ps | OP_DST, AMODE_V | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x29 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "cvtpi2ps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x2A */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movntps", { AMODE_M | OPTYPE_o | OP_DST, AMODE_V | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x2B */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "cvttps2pi", { AMODE_P | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x2C */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "cvtps2pi", { AMODE_P | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x2D */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_CMP, "ucomiss", { AMODE_V | OPTYPE_ss | OP_SRC, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_CF_MOD | FLAG_PF_MOD | FLAG_OF_CLR | FLAG_SF_CLR | FLAG_AF_CLR, NOACTION, IGNORED }, /* 0x2E */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_CMP, "comiss", { AMODE_V | OPTYPE_ps | OP_SRC, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_CF_MOD | FLAG_PF_MOD | FLAG_OF_CLR | FLAG_SF_CLR | FLAG_AF_CLR, NOACTION, IGNORED }, /* 0x2F */
+ { NOGROUP, CPU_PENTIUM, ITYPE_SYSTEM, "wrmsr", { OPTYPE_REG_ECX | OP_MSR | OP_DST, OPTYPE_EDX_HI_EAX_LO | OP_SRC, 0 } , NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x30 */
+ { NOGROUP, CPU_PENTIUM, ITYPE_SYSTEM, "rdtsc", { OPTYPE_EDX_HI_EAX_LO | OP_DST, OPTYPE_TSC | OP_MSR | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x31 */
+ { NOGROUP, CPU_PENTIUM, ITYPE_SYSTEM, "rdmsr", { OPTYPE_EDX_HI_EAX_LO | OP_DST, OPTYPE_REG_ECX | OP_MSR | OP_SRC, 0 } , NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x32 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_OTHER, "rdpmc", { OPTYPE_EDX_HI_EAX_LO | OP_DST, OPTYPE_REG_ECX | OP_SYS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x33 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSCALL, "sysenter", { OPTYPE_CS_MSR | OP_MSR | OP_SRC, OPTYPE_EIP_MSR | OP_MSR | OP_SRC, OPTYPE_ESP_MSR | OP_MSR | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x34 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSCALLRET, "sysexit", { OPTYPE_CS_MSR | OP_MSR | OP_SRC, OPTYPE_EIP_MSR | OP_MSR | OP_SRC, OPTYPE_ESP_MSR | OP_MSR | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x35 */
+ { NOINSTR }, /* 0x36 */
+ { NOINSTR }, /* 0x37 */
+ { NOINSTR }, /* 0x38 */
+ { NOINSTR }, /* 0x39 */
+ { NOINSTR }, /* 0x3A */
+ { NOINSTR }, /* 0x3B */
+ { NOINSTR }, /* 0x3C */
+ { NOINSTR }, /* 0x3D */
+ { NOINSTR }, /* 0x3E */
+ { NOINSTR }, /* 0x3F */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovo", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_O, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x40 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovno", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_NO, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x41 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovc", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_C, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x42 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovnc", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_NC, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x43 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovz", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_Z, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x44 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovnz", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_NZ, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x45 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovbe", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_BE, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x46 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmova", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_A, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x47 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovs", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_S, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x48 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovns", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_NS, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x49 */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovpe", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_PE, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x4A */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovpo", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_PO, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x4B */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovl", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_L, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x4C */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovge", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_GE, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x4D */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovle", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_LE, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x4E */
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_MOVCC, "cmovg", { AMODE_G | OPTYPE_v | OP_COND_DST, AMODE_E | OPTYPE_v | OP_COND_SRC, 0 }, COND_G, NOCHANGE, OP1_DST | OP2_SRC, NOACTION }, /* 0x4F */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "movmskps", { AMODE_G | OPTYPE_d | OP_DST, AMODE_VR | OPTYPE_ps| OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x50 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "sqrtps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x51 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "rsqrtps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x52 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "rcpps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x53 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_AND, "andps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x54 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_AND, "andnps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x55 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_OR, "orps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x56 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_XOR, "xorps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x57 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_ADD, "addps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x58 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MUL, "mulps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x59 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtps2pd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5A */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtdq2ps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5B */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_SUB, "subps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5C */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "minps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5D */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_DIV, "divps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5E */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "maxps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x5F */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "punpcklbw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x60 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "punpcklwd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x61 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "punpckldq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x62 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "packsswb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x63 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_CMP, "pcmpgtb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x64 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_CMP, "pcmpgtw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x65 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_CMP, "pcmpgtd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x66 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "packuswb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x67 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "punpckhbw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x68 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "punpckhwd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x69 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "punpckhdq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_d | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x6A */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "packssdw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x6B */
+ { NOINSTR }, /* 0x6C */
+ { NOINSTR }, /* 0x6D */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_MOV, "movd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_E | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x6E */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_MOV, "movq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x6F */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "pshufw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x70 */
+ { X86_Group_13, GROUP }, /* 0x71 */
+ { X86_Group_14, GROUP }, /* 0x72 */
+ { X86_Group_15, GROUP }, /* 0x73 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_CMP, "pcmpeqb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x74 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_CMP, "pcmpeqw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x75 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_CMP, "pcmpeqd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x76 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "emms", { OPTYPE_FPU_TAG | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x77 */
+ { NOINSTR }, /* 0x78 */
+ { NOINSTR }, /* 0x79 */
+ { NOINSTR }, /* 0x7A */
+ { NOINSTR }, /* 0x7B */
+ { NOINSTR }, /* 0x7C */
+ { NOINSTR }, /* 0x7D */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_MOV, "movd", { AMODE_E | OPTYPE_dq | OP_DST, AMODE_P | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x7E */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_MOV, "movq", { AMODE_Q | OPTYPE_q | OP_DST, AMODE_P | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x7F */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jo", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_O, NOCHANGE, OP1_DST, NOACTION }, /* 0x80 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jno", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NO, NOCHANGE, OP1_DST, NOACTION }, /* 0x81 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jb", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_C, NOCHANGE, OP1_DST, NOACTION }, /* 0x82 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jnb", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NC, NOCHANGE, OP1_DST, NOACTION }, /* 0x83 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jz", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_Z, NOCHANGE, OP1_DST, NOACTION }, /* 0x84 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jnz", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NZ, NOCHANGE, OP1_DST, NOACTION }, /* 0x85 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jbe", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_BE, NOCHANGE, OP1_DST, NOACTION }, /* 0x86 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "ja", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_A, NOCHANGE, OP1_DST, NOACTION }, /* 0x87 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "js", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_S, NOCHANGE, OP1_DST, NOACTION }, /* 0x88 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jns", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_NS, NOCHANGE, OP1_DST, NOACTION }, /* 0x89 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jpe", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_PE, NOCHANGE, OP1_DST, NOACTION }, /* 0x8A */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jpo", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_PO, NOCHANGE, OP1_DST, NOACTION }, /* 0x8B */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jl", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_L, NOCHANGE, OP1_DST, NOACTION }, /* 0x8C */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jge", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_GE, NOCHANGE, OP1_DST, NOACTION }, /* 0x8D */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jle", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_LE, NOCHANGE, OP1_DST, NOACTION }, /* 0x8E */
+ { NOGROUP, CPU_I386, ITYPE_BRANCHCC, "jg", { AMODE_J | OPTYPE_z | OP_SRC | OP_COND_EXEC, 0, 0 }, COND_G, NOCHANGE, OP1_DST, NOACTION }, /* 0x8F */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "seto", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_O, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x90 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setno", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_NO, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x91 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setb", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_C, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x92 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setnb", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_NC, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x93 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "sete", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_Z, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x94 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setne", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_NZ, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x95 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setbe", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_BE, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x96 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "seta", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_A, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x97 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "sets", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_S, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x98 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setns", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_NS, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x99 */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setpe", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_PE, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x9A */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setpo", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_PO, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x9B */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setl", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_L, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x9C */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setge", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_GE, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x9D */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setle", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_LE, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x9E */
+ { NOGROUP, CPU_I386, ITYPE_MOVCC, "setg", { AMODE_E | OPTYPE_b | OP_COND_DST, OPTYPE_1 | OP_COND_SRC, OPTYPE_0 | OP_COND_SRC }, COND_G, NOCHANGE, OP1_DST | OP2_SRC, OP1_DST | OP3_SRC }, /* 0x9F */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OPTYPE_FS | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA0 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OPTYPE_FS | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA1 */
+ { NOGROUP, CPU_PENTIUM, ITYPE_CPUID, "cpuid", { OPTYPE_EDX_ECX_EBX_EAX | OP_DST, OPTYPE_REG_xAX_BIG | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA2 */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "bt", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xA3 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shld", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xA4 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shld", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, OPTYPE_REG_CL | OP_SRC }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xA5 */
+ { NOINSTR }, /* 0xA6 */
+ { NOINSTR }, /* 0xA7 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { OPTYPE_GS | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA8 */
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { OPTYPE_GS | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xA9 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "rsm", NOARGS, NOCOND, FLAG_ALL_MOD, NOACTION, IGNORED }, /* 0xAA */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "bts", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xAB */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shrd", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xAC */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shrd", { AMODE_E | OPTYPE_v | OP_DST, AMODE_G | OPTYPE_v | OP_SRC, OPTYPE_REG_CL | OP_SRC }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xAD */
+ { X86_Group_16, GROUP }, /* 0xAE */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "imul", { AMODE_G | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xAF */
+ { NOGROUP, CPU_I486, ITYPE_XCHGCC, "cmpxchg", { AMODE_E | OPTYPE_b | OP_SRC | OP_COND_DST, OPTYPE_REG_AL | OP_SRC | OP_COND_DST, AMODE_G | OPTYPE_b | OP_COND_SRC }, COND_OP1_EQ_OP2, FLAG_COMMON_MOD, OP1_DST | OP3_SRC, OP2_DST | OP1_SRC }, /* 0xB0 */
+ { NOGROUP, CPU_I486, ITYPE_XCHGCC, "cmpxchg", { AMODE_E | OPTYPE_v | OP_SRC | OP_COND_DST, OPTYPE_REG_xAX_BIG | OP_SRC | OP_COND_DST, AMODE_G | OPTYPE_v | OP_COND_SRC }, COND_OP1_EQ_OP2, FLAG_COMMON_MOD, OP1_DST | OP3_SRC, OP2_DST | OP1_SRC }, /* 0xB1 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "lss", { AMODE_G | OPTYPE_z | OP_DST, AMODE_M | OPTYPE_p | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB2 */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "btr", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xB3 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "lfs", { AMODE_G | OPTYPE_z | OP_DST, AMODE_M | OPTYPE_p | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB4 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "lgs", { AMODE_G | OPTYPE_z | OP_DST, AMODE_M | OPTYPE_p | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB5 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "movzx", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB6 */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "movzx", { AMODE_G | OPTYPE_v | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xB7 */
+ { NOINSTR }, /* 0xB8 */
+ { X86_Group_11, GROUP }, /* 0xB9 */
+ { X86_Group_8, GROUP }, /* 0xBA */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "btc", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_G | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0xBB */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "bsf", { AMODE_G | OPTYPE_v | OP_SRC, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, /* 0xBC */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "bsr", { AMODE_G | OPTYPE_v | OP_SRC, AMODE_E | OPTYPE_v | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, /* 0xBD */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "movsx", { AMODE_G | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBE */
+ { NOGROUP, CPU_I386, ITYPE_MOV, "movsx", { AMODE_G | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xBF */
+ { NOGROUP, CPU_I486, ITYPE_XCHGADD, "xadd", { AMODE_E | OPTYPE_b | OP_SRC | OP_DST, AMODE_G | OPTYPE_b | OP_SRC | OP_DST, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0xC0 */
+ { NOGROUP, CPU_I486, ITYPE_XCHGADD, "xadd", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, AMODE_G | OPTYPE_v | OP_SRC | OP_DST, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0xC1 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_CMP, "cmpps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0xC2 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movnti", { AMODE_M | OPTYPE_dq | OP_DST, AMODE_G | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC3 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pinsrw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC4 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pextrw", { AMODE_G | OPTYPE_d | OP_DST, AMODE_PR | OPTYPE_q | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC5 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "shufps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC6 */
+ { X86_Group_9, GROUP }, /* 0xC7 */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC8 */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC9 */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCA */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCB */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCC */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCD */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCE */
+ { NOGROUP, CPU_I486, ITYPE_XCHG, "bswap", { OP_REG | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xCF */
+ { NOINSTR }, /* 0xD0 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrlw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD1 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrld", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD2 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrlq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD3 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_ADD, "paddq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD4 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_MUL, "pmullw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD5 */
+ { NOINSTR }, /* 0xD6 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pmovmskb", { AMODE_G | OPTYPE_d | OP_DST, AMODE_PR | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD7 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubusb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD8 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubusw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xD9 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pminub", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xDA */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_AND, "pand", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xDB */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddusb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xDC */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddusw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xDD */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pmaxub", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xDE */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_AND, "pandn", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xDF */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pavgb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE0 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psraw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE1 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrad", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE2 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pavgw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE3 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MUL, "pmulhuw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE4 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_MUL, "pmulhw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE5 */
+ { NOINSTR }, /* 0xE6 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MOV, "movntq", { AMODE_M | OPTYPE_q | OP_DST, AMODE_P | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE7 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubsb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE8 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubsw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xE9 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pminsw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEA */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_OR, "por", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEB */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddsb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEC */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddsw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xED */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "pmaxsw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEE */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_XOR, "pxor", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xEF */
+ { NOINSTR }, /* 0xF0 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psllw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF1 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "pslld", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF2 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psllq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF3 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_MUL, "pmuludq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF4 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "pmaddwd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF5 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "psadbw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF6 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "maskmovq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_PR | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF7 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF8 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xF9 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_SUB, "psubd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xFA */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_SUB, "psubq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xFB */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xFC */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xFD */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX_ADD, "paddd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xFE */
+ { NOINSTR } /* 0xFF */,
+};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// Groups
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+X86_OPCODE X86_Group_1_80[8] = // 80
+{
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_E | OPTYPE_b | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_1_81[8] = // 81
+{
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_1_82[8] = // 82
+{
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_1_83[8] = // 83
+{
+ { NOGROUP, CPU_I386, ITYPE_ADD, "add", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_OR, "or", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ADD, "adc", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sbb", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_AND, "and", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SUB, "sub", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_XOR, "xor", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_CMP, "cmp", { AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, AMODE_I | OPTYPE_b | OP_SIGNED | OP_SRC, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_2_C0[8] = // C0
+{
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rol", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "ror", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rcl", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "rcr", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shl", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shr", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "sal", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "sar", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_2_C1[8] = // C1
+{
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rol", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "ror", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rcl", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "rcr", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shl", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shr", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "sal", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "sar", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_2_D0[8] = // D0
+{
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rol", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "ror", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rcl", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "rcr", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shl", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shr", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "sal", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "sar", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_2_D1[8] = // D1
+{
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rol", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "ror", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rcl", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "rcr", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shl", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shr", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "sal", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "sar", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_1 | OP_SRC, 0 }, NOCOND, FLAG_OF_MOD | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_2_D2[8] = // D2
+{
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rol", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "ror", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rcl", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "rcr", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shl", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shr", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "sal", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "sar", { AMODE_E | OPTYPE_b | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_2_D3[8] = // D3
+{
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rol", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "ror", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_ROL, "rcl", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_ROR, "rcr", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "shl", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "shr", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SHL, "sal", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_SHR, "sar", { AMODE_E | OPTYPE_v | OP_DST, OPTYPE_REG_CL | OP_SRC, 0 }, NOCOND, FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_3_F6[8] = // F6
+{
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { AMODE_E | OPTYPE_b | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { AMODE_E | OPTYPE_b | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_NOT, "not", { AMODE_E | OPTYPE_b | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_NEG, "neg", { AMODE_E | OPTYPE_b | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "mul", { OPTYPE_REG_AX | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, OPTYPE_REG_AL | OP_SRC }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "imul", { OPTYPE_REG_AX | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_b | OP_SIGNED | OP_SRC, OPTYPE_REG_AL | OP_SIGNED | OP_SRC }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_DIV, "div", { OPTYPE_REG_AX | OP_DST, AMODE_E | OPTYPE_b | OP_SRC, OPTYPE_REG_AX | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_DIV, "idiv", { OPTYPE_REG_AX | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_b | OP_SIGNED | OP_SRC, OPTYPE_REG_AX | OP_SIGNED | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED } /* 0x07 */,
+};
+
+X86_OPCODE X86_Group_3_F7[8] = // F7
+{
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_TEST, "test", { AMODE_E | OPTYPE_v | OP_SRC, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, FLAG_OF_CLR | FLAG_SF_MOD | FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_CLR, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_NOT, "not", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_NEG, "neg", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "mul", { OPTYPE_xDX_HI_xAX_LO | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, OPTYPE_REG_xAX_BIG | OP_SRC }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_MUL, "imul", { OPTYPE_xDX_HI_xAX_LO | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, OPTYPE_REG_xAX_BIG | OP_SRC }, NOCOND, FLAG_OF_MOD | FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_DIV, "div", { OPTYPE_xDX_HI_xAX_LO | OP_DST, AMODE_E | OPTYPE_v | OP_SRC, OPTYPE_REG_xAX_BIG | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_DIV, "idiv", { OPTYPE_xDX_HI_xAX_LO | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_v | OP_SIGNED | OP_SRC, OPTYPE_REG_xAX_BIG | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_4[8] = // FE
+{
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { AMODE_E | OPTYPE_b | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { AMODE_E | OPTYPE_b | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR } /* 0x07 */
+};
+
+X86_OPCODE X86_Group_5[8] = // FF
+{
+ { NOGROUP, CPU_I386, ITYPE_INC, "inc", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_DEC, "dec", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, 0, 0 }, NOCOND, FLAG_OF_MOD|FLAG_SF_MOD|FLAG_ZF_MOD|FLAG_AF_MOD|FLAG_PF_MOD, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_CALL, "call", { AMODE_E | OPTYPE_v | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_CALL, "call", { AMODE_E | OPTYPE_p | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCH, "jmp", { AMODE_E | OPTYPE_v | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_BRANCH, "jmp", { AMODE_E | OPTYPE_p | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_PUSH, "push", { AMODE_E | OPTYPE_v | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_6[8] = // 0F 00
+{
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "sldt", { AMODE_E | OPTYPE_mw | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "str", { AMODE_E | OPTYPE_mw | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "lldt", { AMODE_E | OPTYPE_w | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "ltr", { AMODE_E | OPTYPE_w | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "verr", { AMODE_E | OPTYPE_w | OP_SRC, 0, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "verw", { AMODE_E | OPTYPE_w | OP_SRC, 0, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_IA64, ITYPE_BRANCH, "jmpe", { AMODE_E | OPTYPE_v | OP_SRC | OP_EXEC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOINSTR } /* 0x07 */
+};
+
+X86_OPCODE X86_Group_7[8] = // 0F 01
+{
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "sgdt", { AMODE_M | OPTYPE_dt | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "sidt", { AMODE_M | OPTYPE_dt | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "lgdt", { AMODE_M | OPTYPE_dt | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "lidt", { AMODE_M | OPTYPE_dt | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "smsw", { AMODE_E | OPTYPE_mw | OP_DST, OPTYPE_CR0 | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "lmsw", { OPTYPE_CR0 | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I486, ITYPE_SYSTEM, "invlpg", { AMODE_M | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_8[8] = // 0F BA
+{
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "bt", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "bts", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "btr", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_BITTEST, "btc", { AMODE_E | OPTYPE_v | OP_SRC | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, FLAG_CF_MOD, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_9[8] = // 0F C7
+{
+ { NOINSTR }, /* 0x00 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_XCHGCC, "cmpxchg8b", { AMODE_M | OPTYPE_q | OP_SRC | OP_COND_DST, OPTYPE_xDX_HI_xAX_LO | OP_SRC | OP_COND_DST, OPTYPE_xCX_HI_xBX_LO | OP_COND_SRC }, COND_OP1_EQ_OP2, FLAG_ZF_MOD, OP1_DST | OP3_SRC, OP2_DST | OP1_SRC }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_10[8] = // 8F (NOTE: AMD64 labels this Group 1A)
+{
+ { NOGROUP, CPU_I386, ITYPE_POP, "pop", { AMODE_E | OPTYPE_v | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_11[8] = // 0F B9 (NOTE: AMD64 labels this Group 10)
+{
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_I386, ITYPE_INVALID, "undef", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED } /* 0x07 */
+};
+
+X86_OPCODE X86_Group_12_C6[8] = // C6 (NOTE: AMD64 labels this Group 11)
+{
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_E | OPTYPE_b | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0xC6 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_12_C7[8] = // C7 (NOTE: AMD64 labels this Group 11)
+{
+ { NOGROUP, CPU_I386, ITYPE_MOV, "mov", { AMODE_E | OPTYPE_v | OP_DST, AMODE_I | OPTYPE_z | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+// NOTE: the X86_SSE2_* is only followed if it is a 3-byte opcode (e.g., prefix is 66, F2, or F3)
+X86_OPCODE X86_Group_13[8] = // 0F 71 (NOTE: AMD64 labels this Group 12)
+{
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrlw", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psraw", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psllw", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_14[8] = // 0F 72 (NOTE: AMD64 labels this Group 13)
+{
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrld", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrad", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "pslld", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_15[8] = // 0F 73 (NOTE: AMD64 labels this Group 14)
+{
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrlq", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psrldq", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "psllq", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_MMX, "pslldq", { AMODE_PR | OPTYPE_q | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED } /* 0x07 */
+};
+
+X86_OPCODE X86_Group_16[8] = // 0F AE (NOTE: AMD64 labels this Group 15)
+{
+ { NOGROUP, CPU_PENTIUM2, ITYPE_FPU, "fxsave", { AMODE_M | OPTYPE_fst2 | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_FPU, "fxrstor", { AMODE_M | OPTYPE_fst2 | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "ldmxcsr", { AMODE_M | OPTYPE_d | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "stmxcsr", { AMODE_M | OPTYPE_d | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "lfence", NOARGS, NOCOND, NOCHANGE, SERIALIZE_READ, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "mfence", NOARGS, NOCOND, NOCHANGE, SERIALIZE_ALL, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "sfence", NOARGS, NOCOND, NOCHANGE, SERIALIZE_WRITE, IGNORED } /* 0x07 */
+};
+
+X86_OPCODE X86_Group_17[8] = // 0F 18 (NOTE: AMD64 labels this Group 16)
+{
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "prefetchnta", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x00 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "prefetcht0", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "prefetcht1", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "prefetcht2", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "hintnop", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "hintnop", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "hintnop", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_PENTIUM2, ITYPE_SYSTEM, "hintnop", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+};
+
+X86_OPCODE X86_Group_P[8] = // 0F 0D
+{
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "prefetch", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x01 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "prefetchw", { AMODE_E | OPTYPE_b | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// FPU (ESC) opcodes
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+
+X86_OPCODE X86_ESC_0[0x48] = // D8
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x00
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x01
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { AMODE_M | OPTYPE_ss | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // 0x02
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { AMODE_M | OPTYPE_ss | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // 0x03
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x04
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x05
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x06
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_ss | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x07
+
+ //
+ // ModRM >= C0: ST(0) <- ST(0) + ST(i)
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // C8-CF
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+ // D0-D7
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x7
+ // D8-DF
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xF
+ // E0-E7
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // E8-EF
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xF
+ // F0-F7
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // F8-FF
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED } // xF
+};
+
+
+X86_OPCODE X86_ESC_1[0x48] = // D9
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { AMODE_M | OPTYPE_ss | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // 0x00
+ { NOINSTR }, // 0x01
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { AMODE_M | OPTYPE_ss | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x02
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { AMODE_M | OPTYPE_ss | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x03
+ { NOGROUP, CPU_I287, ITYPE_FLOADENV, "fldenv", { AMODE_M | OPTYPE_fev | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // 0x04
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldcw", { OPTYPE_FPU_CONTROL | OP_DST, AMODE_M | OPTYPE_w | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // 0x05
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstenv", { AMODE_M | OPTYPE_fev | OP_DST, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // 0x06
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fnstcw", { AMODE_M | OPTYPE_w | OP_DST, OPTYPE_FPU_CONTROL | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // 0x07
+
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { OPTYPE_STx | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x7
+ // C8-CF
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FEXCH, "fxch", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_STx | OP_SRC | OP_DST, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xF
+ // D0-D7
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fnop", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // D8-DF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+ // E0-E7
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fchs", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fabs", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ftst", { OPTYPE_ST0 | OP_SRC, OPTYPE_FLDZ | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fxam", { OPTYPE_ST0 | OP_SRC, 0, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // E8-EF
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld1", { OPTYPE_FLD1 | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldl2t", { OPTYPE_FLDL2T | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldl2e", { OPTYPE_FLDL2E | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldpi", { OPTYPE_FLDPI | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldlg2", { OPTYPE_FLDLG2| OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldln2", { OPTYPE_FLDLN2 | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fldz", { OPTYPE_FLDZ | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // xE
+ { NOINSTR }, // xF
+ // F0-F7
+ { NOGROUP, CPU_I287, ITYPE_FPU, "f2xm1", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fyl2x", { OPTYPE_ST1 | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fptan", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD|FPU_C2_MOD, FPU_STACK_PUSH, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fpatan", { OPTYPE_ST1 | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC , 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fxtract", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_ST1 | OP_DST, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x4
+ { NOGROUP, CPU_I387, ITYPE_FPU, "fprem1", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_ST1 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fdecstp", NOARGS, NOCOND, FPU_C1_MOD, FPU_STACK_DEC, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fincstp", NOARGS, NOCOND, FPU_C1_MOD, FPU_STACK_INC, IGNORED }, // x7
+ // F8-FF
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fprem", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_ST1 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fyl2xp1", { OPTYPE_ST1 | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fsqrt", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fsincos", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD|FPU_C2_MOD, FPU_STACK_PUSH, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FPU, "frndint", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fscale", { OPTYPE_ST0 | OP_SRC | OP_DST, OPTYPE_ST1 | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fsin", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD|FPU_C2_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fcos", { OPTYPE_ST0 | OP_SRC | OP_DST, 0, 0 }, NOCOND, FPU_C1_MOD|FPU_C2_MOD, NOACTION, IGNORED } // xF
+};
+
+
+X86_OPCODE X86_ESC_2[0x48] = // DA
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fiadd", { OPTYPE_ST0 | OP_SIGNED | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fimul", { OPTYPE_ST0 | OP_SIGNED | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "ficom", { AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, OPTYPE_ST0 | OP_SRC | OP_DST, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "ficomp", { AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, OPTYPE_ST0 | OP_SRC | OP_DST, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fisub", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fisubr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fidiv", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fidivr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x0
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x1
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x2
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x3
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x4
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x5
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x6
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_B, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x7
+ // C8-CF
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x8
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x9
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xA
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xB
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xC
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xD
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xE
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmove", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_E, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xF
+ // D0-D7
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x0
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x1
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x2
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x3
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x4
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x5
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x6
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_BE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x7
+ // D8-DF
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x8
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x9
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xA
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xB
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xC
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xD
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xE
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FMOVCC, "fcmovu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_COND_SRC, 0 }, COND_U, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xF
+ // E0-E7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // E8-EF
+ { NOINSTR }, // x8
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucompp", { OPTYPE_ST1 | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP2, IGNORED }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+ // F0-F7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // F8-FF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR } // xF
+};
+
+
+
+X86_OPCODE X86_ESC_3[0x48] = // DB
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fild", { AMODE_M | OPTYPE_d | OP_SIGNED | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // 0x00
+ { NOGROUP, CPU_PENTIUM4, ITYPE_FSTORE, "fisttp", { AMODE_M | OPTYPE_d | OP_SIGNED | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x01
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fist", { AMODE_M | OPTYPE_d | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x02
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fistp", { AMODE_M | OPTYPE_d | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x03
+ { NOINSTR }, // 0x04
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { AMODE_M | OPTYPE_se | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // 0x05
+ { NOINSTR }, // 0x06
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { AMODE_M | OPTYPE_se | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x07
+
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x0
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x1
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x2
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x3
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x4
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x5
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x6
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnb", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NB, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x7
+ // C8-CF
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x8
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x9
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xA
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xB
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xC
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xD
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xE
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovne", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xF
+ // D0-D7
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x0
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x1
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x2
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x3
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x4
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x5
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x6
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnbe", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NBE, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x7
+ // D8-DF
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x8
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // x9
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xA
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xB
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xC
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xD
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xE
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FPU, "fcmovnu", { OPTYPE_ST0 | OP_COND_DST, OPTYPE_STx | OP_SRC, 0 }, COND_NU, FPU_C1_MOD, OP1_DST | OP2_SRC, NOACTION }, // xF
+ // E0-E7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FPU, "fnclex", { OPTYPE_FPU_STATUS | OP_DST, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FPU, "finit", { OPTYPE_FPU_STATUS | OP_DST, 0, 0 }, NOCOND, FPU_ALL_CLR, NOACTION, IGNORED }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // E8-EF
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // xF
+ // F0-F7
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomi", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, NOACTION, IGNORED }, // x7
+ // F8-FF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR } // xF
+};
+
+X86_OPCODE X86_ESC_4[0x48] = // DC
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x00
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x01
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcom", { AMODE_M | OPTYPE_sd | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // 0x02
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcomp", { AMODE_M | OPTYPE_sd | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // 0x03
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x04
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x05
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x06
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x07
+
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fadd", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // C8-CF
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmul", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xF
+ // D0-D7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // D8-DF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+ // E0-E7
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // E8-EF
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsub", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xF
+ // F0-F7
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivr", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // F8-FF
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdiv", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED } // xF
+};
+
+
+X86_OPCODE X86_ESC_5[0x48] = // DD
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fld", { AMODE_M | OPTYPE_sd | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_FSTORE, "fisttp", { AMODE_M | OPTYPE_d | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { AMODE_M | OPTYPE_sd | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { AMODE_M | OPTYPE_sd | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FRESTORE, "frstor", { AMODE_M | OPTYPE_fst1 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x4
+ { NOINSTR }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FSAVE, "fsave", { AMODE_M | OPTYPE_fst1 | OP_DST, 0 }, NOCOND, FPU_ALL_CLR, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fnstsw", { AMODE_M | OPTYPE_w | OP_DST, OPTYPE_FPU_STATUS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FPU, "ffree", { OPTYPE_FPU_TAG | OP_DST, OPTYPE_STx | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ // C8-CF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+ // D0-D7
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fst", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // x7
+ // D8-DF
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fstp", { OPTYPE_STx | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xF
+ // E0-E7
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucom", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // x7
+ // E8-EF
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_I387, ITYPE_FCOMP, "fucomp", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xF
+ // F0-F7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // F8-FF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR } // xF
+};
+
+
+X86_OPCODE X86_ESC_6[0x48] = // DE
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FADD, "fiadd", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x00
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fimul", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x01
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "ficom", { AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, NOACTION, IGNORED }, // 0x02
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "ficomp", { AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // 0x03
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fisub", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x04
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fisubr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x05
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fidiv", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x06
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fidivr", { OPTYPE_ST0 | OP_SRC | OP_DST, AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x07
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+
+ // C0-C7
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FADD, "faddp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x7
+ // C8-CF
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FMUL, "fmulp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xF
+ // D0-D7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // D8-DF
+ { NOINSTR }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FCOMP, "fcompp", { OPTYPE_ST1 | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_ALL_MOD, FPU_STACK_POP2, IGNORED }, // x9
+ { NOINSTR }, // 0xA
+ { NOINSTR }, // 0xB
+ { NOINSTR }, // 0xC
+ { NOINSTR }, // 0xD
+ { NOINSTR }, // 0xE
+ { NOINSTR }, // 0xF
+ // E0-E7
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x7
+ // E8-EF
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FSUB, "fsubp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xF
+ // F0-F7
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x0
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x1
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x2
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x4
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x5
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x6
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivrp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x7
+ // F8-FF
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_I287, ITYPE_FDIV, "fdivp", { OPTYPE_STx | OP_SRC | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED } // xF
+};
+
+
+X86_OPCODE X86_ESC_7[0x48] = // DF
+{
+ //
+ // ModRM < C0
+ // Index 0x00-0x07 = opcode extension
+ //
+
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fild", { AMODE_M | OPTYPE_w | OP_SIGNED | OP_SRC, 0, 0}, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // 0x00
+ { NOGROUP, CPU_PENTIUM4, ITYPE_FSTORE, "fisttp", { AMODE_M | OPTYPE_w | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x01
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fist", { AMODE_M | OPTYPE_w | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, NOACTION, IGNORED }, // 0x02
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fistp", { AMODE_M | OPTYPE_w | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x03
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fbld", { AMODE_M | OPTYPE_pb | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // 0x04
+ { NOGROUP, CPU_I287, ITYPE_FLOAD, "fild", { AMODE_M | OPTYPE_q | OP_SIGNED | OP_SRC, 0, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_PUSH, IGNORED }, // 0x05
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fbstp", { AMODE_M | OPTYPE_pb | OP_DST, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x06
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fistp", { AMODE_M | OPTYPE_q | OP_SIGNED | OP_DST, OPTYPE_ST0 | OP_SRC, 0}, NOCOND, FPU_C1_MOD, FPU_STACK_POP, IGNORED }, // 0x07
+
+ //
+ // ModRM >= C0
+ // Index 0x08-0x47 = ModRM 0xC0-0xFF
+ //
+ // C0-C7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // C8-CF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+ // D0-D7
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // D8-DF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+ // E0-E7
+ { NOGROUP, CPU_I287, ITYPE_FSTORE, "fnstsw", { OPTYPE_REG_AX | OP_DST, OPTYPE_FPU_STATUS | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ // E8-EF
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fucomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // xF
+ // F0-F7
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM_PRO, ITYPE_FCOMP, "fcomip", { OPTYPE_STx | OP_SRC, OPTYPE_ST0 | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_PF_MOD | FLAG_CF_MOD | FPU_ALL_MOD, FPU_STACK_POP, IGNORED }, // x7
+ // F8-FF
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR } // xF
+};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// SSE opcodes
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+X86_OPCODE X86_SSE[0x300] =
+{
+ // prefix 0x66 (operand size)
+ /* 0x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 1x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movupd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movupd", { AMODE_W | OPTYPE_pd | OP_DST, AMODE_V | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movlpd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_M | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movlpd", { AMODE_M | OPTYPE_q | OP_DST, AMODE_V | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "unpcklpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "unpckhpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movhpd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_M | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "mpvhpd", { AMODE_M | OPTYPE_q | OP_DST, AMODE_V | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 2x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movapd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movapd", { AMODE_W | OPTYPE_o | OP_DST, AMODE_V | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtpi2pd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movntpd", { AMODE_M | OPTYPE_o | OP_DST, AMODE_V | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvttpd2pi", { AMODE_P | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtpd2pi", { AMODE_P | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "ucomisd", { AMODE_V | OPTYPE_sd | OP_SRC, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_CF_MOD | FLAG_PF_MOD | FLAG_OF_CLR | FLAG_SF_CLR | FLAG_AF_CLR, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "comisd", { AMODE_V | OPTYPE_pd | OP_SRC, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD | FLAG_CF_MOD | FLAG_PF_MOD | FLAG_OF_CLR | FLAG_SF_CLR | FLAG_AF_CLR, NOACTION, IGNORED }, // xF
+
+ /* 3x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 4x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 5x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "movmskpd", { AMODE_G | OPTYPE_d | OP_DST, AMODE_VR | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "sqrtpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_AND, "andpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_AND, "andnpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_OR, "orpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_XOR, "xorpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "addpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "mulpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtpd2ps", { AMODE_V | OPTYPE_ps | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtps2dq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "subpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "minpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_DIV, "divpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "maxpd", { AMODE_V | OPTYPE_pd | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 6x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpcklbw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpcklwd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpckldq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "packsswb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pcmpgtb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pcmpgtw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pcmpgtd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "packuswb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpckhbw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpckhwd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpckhdq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "packssdw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpcklqdq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "punpckhqdq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_E | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movdqa", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 7x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pshufd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { X86_SSE2_Group_13, GROUP }, // x1
+ { X86_SSE2_Group_14, GROUP }, // x2
+ { X86_SSE2_Group_15, GROUP }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "pcmpeqb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "pcmpeqw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "pcmpeqd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_ADD, "haddpd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_SUB, "hsubpd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movd", { AMODE_E | OPTYPE_dq | OP_DST, AMODE_V | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movdqa", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 8x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 9x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Ax */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Bx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Cx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "cmppd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, // x2
+ { NOINSTR }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pinsrw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_E | OPTYPE_w | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pextrw", { AMODE_G | OPTYPE_d | OP_DST, AMODE_VR| OPTYPE_o | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "shufpd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Dx */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3, "addsubpd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrlw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrld", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrlq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "pmullw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movq", { AMODE_W | OPTYPE_q | OP_DST, AMODE_V | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pmovmskb", { AMODE_G | OPTYPE_d | OP_DST, AMODE_VR| OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubusb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubusw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pminub", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_AND, "pand", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddusb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddusw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pmaxub", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_AND, "pandn", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* Ex */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pavgb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psraw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrad", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pavgw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "pmulhuw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "pmulhw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvttpd2dq", { AMODE_V | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movntdq", { AMODE_M | OPTYPE_o | OP_DST, AMODE_V | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubsb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubsw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pminsw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_OR, "por", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddsb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddsw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pmaxuw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_XOR, "pxor", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* Fx */
+ { NOINSTR }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psllw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pslld", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psllq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "pmuludq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x4
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "pmaddwd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psadbw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "maskmovdqu", { AMODE_V | OPTYPE_o | OP_DST, AMODE_VR| OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "psubq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddb", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddw", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "paddd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOINSTR }, // xF
+
+ // prefix 0xf2 (repne)
+ /* 0x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 1x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movsd", { AMODE_V | OPTYPE_sdo | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movsd", { AMODE_W | OPTYPE_sd | OP_DST, AMODE_V | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_MOV, "movddup", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 2x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtsi2sd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_E | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOINSTR }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvttsd2si", { AMODE_G | OPTYPE_dq | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtsd2si", { AMODE_G | OPTYPE_dq | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 3x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 4x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 5x */
+ { NOINSTR }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "sqrtsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "addsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "mulsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtsd2ss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOINSTR }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "subsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "minsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_DIV, "divsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "maxsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 6x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movdqa", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 7x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pshuflw", { AMODE_V | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_ADD, "haddps", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_SUB, "hsubps", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 8x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 9x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Ax */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Bx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Cx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_CMP, "cmpsd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_sd | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Dx */
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE3, "addsubps", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movdq2q", { AMODE_P | OPTYPE_q | OP_DST, AMODE_VR | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Ex */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtpd2dq", { AMODE_V | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_pd | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Fx */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3, "lddqu", { AMODE_V | OPTYPE_o | OP_DST, AMODE_M | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ // prefix 0xf3 (rep)
+ /* 0x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 1x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movss", { AMODE_V | OPTYPE_sso | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movss", { AMODE_W | OPTYPE_ss | OP_DST, AMODE_V | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_MOV, "movsldup", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE3_MOV, "movshdup", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 2x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "cvtsi2ss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_E | OPTYPE_dq | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOINSTR }, // xB
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "cvttss2si", { AMODE_G | OPTYPE_dq | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE, "cvtss2si", { AMODE_G | OPTYPE_dq | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 3x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 4x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 5x */
+ { NOINSTR }, // x0
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "sqrtss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x1
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "rsqrtss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x2
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "rcpss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_ADD, "addss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MUL, "mulss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x9
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtss2sd", { AMODE_V | OPTYPE_sd | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xA
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvttps2dq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_ps | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xB
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_SUB, "subss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xC
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "minss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_DIV, "divss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "maxss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 6x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movdqu", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 7x */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pshufhw", { AMODE_V | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movq", { AMODE_V | OPTYPE_q | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xE
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movdqu", { AMODE_W | OPTYPE_o | OP_DST, AMODE_V | OPTYPE_o | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // xF
+
+ /* 8x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* 9x */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Ax */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Bx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Cx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOGROUP, CPU_PENTIUM3, ITYPE_SSE_CMP, "cmpss", { AMODE_V | OPTYPE_ss | OP_DST, AMODE_W | OPTYPE_ss | OP_SRC, AMODE_I | OPTYPE_b | OP_SRC }, NOCOND, FLAG_COMMON_MOD, NOACTION, IGNORED }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Dx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2_MOV, "movq2dq", { AMODE_V | OPTYPE_o | OP_DST, AMODE_PR | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Ex */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "cvtdq2pd", { AMODE_V | OPTYPE_o | OP_DST, AMODE_W | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR }, // xF
+
+ /* Fx */
+ { NOINSTR }, // x0
+ { NOINSTR }, // x1
+ { NOINSTR }, // x2
+ { NOINSTR }, // x3
+ { NOINSTR }, // x4
+ { NOINSTR }, // x5
+ { NOINSTR }, // x6
+ { NOINSTR }, // x7
+ { NOINSTR }, // x8
+ { NOINSTR }, // x9
+ { NOINSTR }, // xA
+ { NOINSTR }, // xB
+ { NOINSTR }, // xC
+ { NOINSTR }, // xD
+ { NOINSTR }, // xE
+ { NOINSTR } // xF
+};
+
+X86_OPCODE X86_SSE2_Group_13[24] = // 66/F2/F3 0F 71
+{
+ // prefix 0x66 (operand size)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrlw", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psraw", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psllw", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+
+ // prefix 0xf2 (repne)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+
+ // prefix 0xf3 (rep)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_SSE2_Group_14[24] = // 66/F2/F3 0F 72
+{
+ // prefix 0x66 (operand size)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrld", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrad", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pslld", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+
+ // prefix 0xf2 (repne)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+
+ // prefix 0xf3 (rep)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+X86_OPCODE X86_SSE2_Group_15[24] =
+{
+ // prefix 0x66 (operand size)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrlq", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x02 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psrldq", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "psllq", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x06 */
+ { NOGROUP, CPU_PENTIUM4, ITYPE_SSE2, "pslldq", { AMODE_VR | OPTYPE_o | OP_DST, AMODE_I | OPTYPE_b | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0x07 */
+
+ // prefix 0xf2 (repne)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+
+ // prefix 0xf3 (rep)
+ { NOINSTR }, /* 0x00 */
+ { NOINSTR }, /* 0x01 */
+ { NOINSTR }, /* 0x02 */
+ { NOINSTR }, /* 0x03 */
+ { NOINSTR }, /* 0x04 */
+ { NOINSTR }, /* 0x05 */
+ { NOINSTR }, /* 0x06 */
+ { NOINSTR }, /* 0x07 */
+};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// 3DNow opcodes
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+X86_OPCODE X86_3DNOW_0F[0x100] =
+{
+ { NOINSTR }, /* 00 */
+ { NOINSTR }, /* 01 */
+ { NOINSTR }, /* 02 */
+ { NOINSTR }, /* 03 */
+ { NOINSTR }, /* 04 */
+ { NOINSTR }, /* 05 */
+ { NOINSTR }, /* 06 */
+ { NOINSTR }, /* 07 */
+ { NOINSTR }, /* 08 */
+ { NOINSTR }, /* 09 */
+ { NOINSTR }, /* 0A */
+ { NOINSTR }, /* 0B */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pi2fw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0C */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pi2fd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 0D */
+ { NOINSTR }, /* 0E */
+ { NOINSTR }, /* 0F */
+ { NOINSTR }, /* 10 */
+ { NOINSTR }, /* 11 */
+ { NOINSTR }, /* 12 */
+ { NOINSTR }, /* 13 */
+ { NOINSTR }, /* 14 */
+ { NOINSTR }, /* 15 */
+ { NOINSTR }, /* 16 */
+ { NOINSTR }, /* 17 */
+ { NOINSTR }, /* 18 */
+ { NOINSTR }, /* 19 */
+ { NOINSTR }, /* 1A */
+ { NOINSTR }, /* 1B */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pf2iw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 1C */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pf2id", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 1D */
+ { NOINSTR }, /* 1E */
+ { NOINSTR }, /* 1F */
+ { NOINSTR }, /* 20 */
+ { NOINSTR }, /* 21 */
+ { NOINSTR }, /* 22 */
+ { NOINSTR }, /* 23 */
+ { NOINSTR }, /* 24 */
+ { NOINSTR }, /* 25 */
+ { NOINSTR }, /* 26 */
+ { NOINSTR }, /* 27 */
+ { NOINSTR }, /* 28 */
+ { NOINSTR }, /* 29 */
+ { NOINSTR }, /* 2A */
+ { NOINSTR }, /* 2B */
+ { NOINSTR }, /* 2C */
+ { NOINSTR }, /* 2D */
+ { NOINSTR }, /* 2E */
+ { NOINSTR }, /* 2F */
+ { NOINSTR }, /* 30 */
+ { NOINSTR }, /* 31 */
+ { NOINSTR }, /* 32 */
+ { NOINSTR }, /* 33 */
+ { NOINSTR }, /* 34 */
+ { NOINSTR }, /* 35 */
+ { NOINSTR }, /* 36 */
+ { NOINSTR }, /* 37 */
+ { NOINSTR }, /* 38 */
+ { NOINSTR }, /* 39 */
+ { NOINSTR }, /* 3A */
+ { NOINSTR }, /* 3B */
+ { NOINSTR }, /* 3C */
+ { NOINSTR }, /* 3D */
+ { NOINSTR }, /* 3E */
+ { NOINSTR }, /* 3F */
+ { NOINSTR }, /* 40 */
+ { NOINSTR }, /* 41 */
+ { NOINSTR }, /* 42 */
+ { NOINSTR }, /* 43 */
+ { NOINSTR }, /* 44 */
+ { NOINSTR }, /* 45 */
+ { NOINSTR }, /* 46 */
+ { NOINSTR }, /* 47 */
+ { NOINSTR }, /* 48 */
+ { NOINSTR }, /* 49 */
+ { NOINSTR }, /* 4A */
+ { NOINSTR }, /* 4B */
+ { NOINSTR }, /* 4C */
+ { NOINSTR }, /* 4D */
+ { NOINSTR }, /* 4E */
+ { NOINSTR }, /* 4F */
+ { NOINSTR }, /* 50 */
+ { NOINSTR }, /* 51 */
+ { NOINSTR }, /* 52 */
+ { NOINSTR }, /* 53 */
+ { NOINSTR }, /* 54 */
+ { NOINSTR }, /* 55 */
+ { NOINSTR }, /* 56 */
+ { NOINSTR }, /* 57 */
+ { NOINSTR }, /* 58 */
+ { NOINSTR }, /* 59 */
+ { NOINSTR }, /* 5A */
+ { NOINSTR }, /* 5B */
+ { NOINSTR }, /* 5C */
+ { NOINSTR }, /* 5D */
+ { NOINSTR }, /* 5E */
+ { NOINSTR }, /* 5F */
+ { NOINSTR }, /* 60 */
+ { NOINSTR }, /* 61 */
+ { NOINSTR }, /* 62 */
+ { NOINSTR }, /* 63 */
+ { NOINSTR }, /* 64 */
+ { NOINSTR }, /* 65 */
+ { NOINSTR }, /* 66 */
+ { NOINSTR }, /* 67 */
+ { NOINSTR }, /* 68 */
+ { NOINSTR }, /* 69 */
+ { NOINSTR }, /* 6A */
+ { NOINSTR }, /* 6B */
+ { NOINSTR }, /* 6C */
+ { NOINSTR }, /* 6D */
+ { NOINSTR }, /* 6E */
+ { NOINSTR }, /* 6F */
+ { NOINSTR }, /* 70 */
+ { NOINSTR }, /* 71 */
+ { NOINSTR }, /* 72 */
+ { NOINSTR }, /* 73 */
+ { NOINSTR }, /* 74 */
+ { NOINSTR }, /* 75 */
+ { NOINSTR }, /* 76 */
+ { NOINSTR }, /* 77 */
+ { NOINSTR }, /* 78 */
+ { NOINSTR }, /* 79 */
+ { NOINSTR }, /* 7A */
+ { NOINSTR }, /* 7B */
+ { NOINSTR }, /* 7C */
+ { NOINSTR }, /* 7D */
+ { NOINSTR }, /* 7E */
+ { NOINSTR }, /* 7F */
+ { NOINSTR }, /* 80 */
+ { NOINSTR }, /* 81 */
+ { NOINSTR }, /* 82 */
+ { NOINSTR }, /* 83 */
+ { NOINSTR }, /* 84 */
+ { NOINSTR }, /* 85 */
+ { NOINSTR }, /* 86 */
+ { NOINSTR }, /* 87 */
+ { NOINSTR }, /* 88 */
+ { NOINSTR }, /* 89 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfnacc", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 8A */
+ { NOINSTR }, /* 8B */
+ { NOINSTR }, /* 8C */
+ { NOINSTR }, /* 8D */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfpnacc", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 8E */
+ { NOINSTR }, /* 8F */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_CMP, "pfcmpge", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 90 */
+ { NOINSTR }, /* 91 */
+ { NOINSTR }, /* 92 */
+ { NOINSTR }, /* 93 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfmin", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 94 */
+ { NOINSTR }, /* 95 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfrcp", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 96 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfrsqrt", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 97 */
+ { NOINSTR }, /* 98 */
+ { NOINSTR }, /* 99 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_SUB, "pfsub", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 9A */
+ { NOINSTR }, /* 9B */
+ { NOINSTR }, /* 9C */
+ { NOINSTR }, /* 9D */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_ADD, "pfadd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* 9E */
+ { NOINSTR }, /* 9F */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_CMP, "pfcmpgt", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* A0 */
+ { NOINSTR }, /* A1 */
+ { NOINSTR }, /* A2 */
+ { NOINSTR }, /* A3 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfmax", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* A4 */
+ { NOINSTR }, /* A5 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfrcpit1", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* A6 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfrsqit1", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* A7 */
+ { NOINSTR }, /* A8 */
+ { NOINSTR }, /* A9 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_SUB, "pfsubr", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* AA */
+ { NOINSTR }, /* AB */
+ { NOINSTR }, /* AC */
+ { NOINSTR }, /* AD */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfacc", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* AE */
+ { NOINSTR }, /* AF */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_CMP, "pfcmpeq", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* B0 */
+ { NOINSTR }, /* B1 */
+ { NOINSTR }, /* B2 */
+ { NOINSTR }, /* B3 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_MUL, "pfmul", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* B4 */
+ { NOINSTR }, /* B5 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pfrcpit2", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* B6 */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_MUL, "pmulhrw", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* B7 */
+ { NOINSTR }, /* B8 */
+ { NOINSTR }, /* B9 */
+ { NOINSTR }, /* BA */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW_XCHG, "pswapd", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* BB */
+ { NOINSTR }, /* BC */
+ { NOINSTR }, /* BD */
+ { NOINSTR }, /* BE */
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_3DNOW, "pavgb", { AMODE_P | OPTYPE_q | OP_DST, AMODE_Q | OPTYPE_q | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, /* BF */
+ { NOINSTR }, /* C0 */
+ { NOINSTR }, /* C1 */
+ { NOINSTR }, /* C2 */
+ { NOINSTR }, /* C3 */
+ { NOINSTR }, /* C4 */
+ { NOINSTR }, /* C5 */
+ { NOINSTR }, /* C6 */
+ { NOINSTR }, /* C7 */
+ { NOINSTR }, /* C8 */
+ { NOINSTR }, /* C9 */
+ { NOINSTR }, /* CA */
+ { NOINSTR }, /* CB */
+ { NOINSTR }, /* CC */
+ { NOINSTR }, /* CD */
+ { NOINSTR }, /* CE */
+ { NOINSTR }, /* CF */
+ { NOINSTR }, /* D0 */
+ { NOINSTR }, /* D1 */
+ { NOINSTR }, /* D2 */
+ { NOINSTR }, /* D3 */
+ { NOINSTR }, /* D4 */
+ { NOINSTR }, /* D5 */
+ { NOINSTR }, /* D6 */
+ { NOINSTR }, /* D7 */
+ { NOINSTR }, /* D8 */
+ { NOINSTR }, /* D9 */
+ { NOINSTR }, /* DA */
+ { NOINSTR }, /* DB */
+ { NOINSTR }, /* DC */
+ { NOINSTR }, /* DD */
+ { NOINSTR }, /* DE */
+ { NOINSTR }, /* DF */
+ { NOINSTR }, /* E0 */
+ { NOINSTR }, /* E1 */
+ { NOINSTR }, /* E2 */
+ { NOINSTR }, /* E3 */
+ { NOINSTR }, /* E4 */
+ { NOINSTR }, /* E5 */
+ { NOINSTR }, /* E6 */
+ { NOINSTR }, /* E7 */
+ { NOINSTR }, /* E8 */
+ { NOINSTR }, /* E9 */
+ { NOINSTR }, /* EA */
+ { NOINSTR }, /* EB */
+ { NOINSTR }, /* EC */
+ { NOINSTR }, /* ED */
+ { NOINSTR }, /* EE */
+ { NOINSTR }, /* EF */
+ { NOINSTR }, /* F0 */
+ { NOINSTR }, /* F1 */
+ { NOINSTR }, /* F2 */
+ { NOINSTR }, /* F3 */
+ { NOINSTR }, /* F4 */
+ { NOINSTR }, /* F5 */
+ { NOINSTR }, /* F6 */
+ { NOINSTR }, /* F7 */
+ { NOINSTR }, /* F8 */
+ { NOINSTR }, /* F9 */
+ { NOINSTR }, /* FA */
+ { NOINSTR }, /* FB */
+ { NOINSTR }, /* FC */
+ { NOINSTR }, /* FD */
+ { NOINSTR }, /* FE */
+ { NOINSTR } /* FF */
+};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// 64-bit replacement opcodes
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+X86_OPCODE X86_Opcode_63[2] =
+{
+ { NOGROUP, CPU_I386, ITYPE_SYSTEM, "arpl", { AMODE_E | OPTYPE_w | OP_SRC, AMODE_G | OPTYPE_w | OP_SRC, 0 }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, // !ARCH_AMD64
+ { NOGROUP, CPU_AMD64, ITYPE_MOV, "movsxd", { AMODE_G | OPTYPE_v | OP_SIGNED | OP_DST, AMODE_E | OPTYPE_d | OP_SIGNED | OP_SRC, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED } // ARCH_AMD64
+};
+
+X86_OPCODE X86_Opcode_0F05[2] =
+{
+ { NOGROUP, CPU_AMD_K6_2, ITYPE_SYSCALL, "syscall", { OPTYPE_STAR_MSR | OP_MSR | OP_SRC, OPTYPE_CSTAR_MSR | OP_MSR | OP_SRC, OPTYPE_FMASK_MSR | OP_MSR | OP_SRC }, NOCOND, FLAG_ZF_MOD, NOACTION, IGNORED }, // !ARCH_AMD64
+ { NOGROUP, CPU_AMD64, ITYPE_SYSCALL, "syscall", { OPTYPE_STAR_MSR | OP_MSR | OP_SRC, OPTYPE_LSTAR_MSR | OP_MSR | OP_SRC, OPTYPE_FMASK_MSR | OP_MSR | OP_SRC }, NOCOND, NOCHANGE, NOACTION, IGNORED } // ARCH_AMD64
+};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// Other 3 byte opcodes
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+// Three byte opcodes where the third opcode byte is ModRM
+X86_OPCODE X86_0F01_ModRM[0x100] =
+{
+ /* 0x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 1x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 2x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 3x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 4x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 5x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 6x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 7x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 8x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* 9x */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* Ax */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* Bx */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* Cx */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { NOGROUP, CPU_PRESCOTT, ITYPE_SYSTEM, "monitor", NOARGS, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { NOGROUP, CPU_PRESCOTT, ITYPE_SYSTEM, "mwait", NOARGS, NOCOND, NOCHANGE, SERIALIZE_ALL, IGNORED }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* Dx */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* Ex */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { X86_Group_7, GROUP }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP }, // xF
+
+ /* Fx */
+ { X86_Group_7, GROUP }, // x0
+ { X86_Group_7, GROUP }, // x1
+ { X86_Group_7, GROUP }, // x2
+ { X86_Group_7, GROUP }, // x3
+ { X86_Group_7, GROUP }, // x4
+ { X86_Group_7, GROUP }, // x5
+ { X86_Group_7, GROUP }, // x6
+ { X86_Group_7, GROUP }, // x7
+ { NOGROUP, CPU_AMD64, ITYPE_SYSTEM, "swapgs", { OPTYPE_KERNELBASE_MSR | OP_MSR | OP_SRC, 0, 0 }, NOCOND, NOCHANGE, NOACTION, IGNORED }, // x8
+ { X86_Group_7, GROUP }, // x9
+ { X86_Group_7, GROUP }, // xA
+ { X86_Group_7, GROUP }, // xB
+ { X86_Group_7, GROUP }, // xC
+ { X86_Group_7, GROUP }, // xD
+ { X86_Group_7, GROUP }, // xE
+ { X86_Group_7, GROUP } // xF
+};
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+// Sanity checking tables
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+
+#define S2 1 // SSE2
+#define S3 2 // SSE3
+BYTE X86_ModRM_1[0x100] =
+{
+ // x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
+ /* 0x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 1x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 2x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 3x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 6x */ 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0,
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 8x */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Cx */ 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Dx */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Fx */ 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1
+};
+BYTE X86_ModRM_2[0x100] =
+{
+ // x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
+ /* 0x */ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,
+ /* 1x */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ /* 2x */ 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 4x */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 6x */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 7x */ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1,
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 9x */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* Ax */ 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1,
+ /* Bx */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1,
+ /* Cx */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Dx */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* Ex */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* Fx */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0
+};
+
+BYTE X86_SSE_2[0x100] =
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 1x */ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0,
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 5x */ 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1,
+ /* 7x */ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Cx */ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Dx */ 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ex */ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Fx */ 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+// Indicates if a LOCK prefix is allowed
+// The following are allowed:
+// add, adc, and, btc, btr, bts, cmpxchg, cmpxchg8, dec, inc,
+// neg, not, or, sbb, sub, xor, xadd, xchg
+#define GR 2
+BYTE X86_LockPrefix_1[0x100] =
+{
+ // x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
+ /* 0x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 1x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 2x */ 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ /* 3x */ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 8x */ GR, GR, GR, GR, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Cx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Dx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Fx */ 0, 0, 0, 0, 0, 0, GR, GR, 0, 0, 0, 0, 0, 0, GR, GR
+};
+
+BYTE X86_LockPrefix_2[0x100] =
+{
+ // x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
+ /* 0x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 1x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+ /* Bx */ 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, GR, 1, 0, 0, 0, 0,
+ /* Cx */ 1, 1, 0, 0, 0, 0, 0, GR, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Dx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ /* Fx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+BYTE X86_LockPrefix_Groups[17][8] =
+{
+// x0 x1 x2 x3 x4 x5 x6 x7
+ { 1, 1, 1, 1, 1, 1, 1, 0 }, // group 1
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 2
+ { 0, 0, 1, 1, 0, 0, 0, 0 }, // group 3
+ { 1, 1, 0, 0, 0, 0, 0, 0 }, // group 4
+ { 1, 1, 0, 0, 0, 0, 0, 0 }, // group 5
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 6
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 7
+ { 0, 0, 0, 0, 1, 1, 1, 1 }, // group 8
+ { 0, 1, 0, 0, 0, 0, 0, 0 }, // group 9
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 10
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 11
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 12
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 13
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 14
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 15
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 16
+ { 0, 0, 0, 0, 0, 0, 0, 0 }, // group 17
+};
+
+#define X86_MAX_GROUP 19
+BYTE X86_Groups_1[0x100] = // one-byte opcodes
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
+ /* 1x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
+ /* 8x */ 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, /* 8x */
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 9x */
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ax */
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
+ /* Cx */ 2, 2, 0, 0, 0, 0, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0, /* Cx */
+ /* Dx */ 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Dx */
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ex */
+ /* Fx */ 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 4, 5 /* Fx */
+};
+
+// 19 = Group P
+// 20 = 3DNow
+BYTE X86_Groups_2[0x100] = // two-byte opcodes
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, /* 0x */
+ /* 1x */ 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, /* 1x */
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */
+ /* 7x */ 0, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 8x */
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 9x */
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, /* Ax */
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 8, 0, 0, 0, 0, 0, /* Bx */
+ /* Cx */ 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, /* Cx */
+ /* Dx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Dx */
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ex */
+ /* Fx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* Fx */
+};
+
+// Indicate which 1-byte opcodes are invalid with a 16-bit operand size
+BYTE X86_Invalid_Op16_1[0x100] =
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
+ /* 1x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 8x */
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 9x */
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ax */
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
+ /* Cx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Cx */
+ /* Dx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Dx */
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ex */
+ /* Fx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* Fx */
+};
+
+// Indicate which 2-byte opcodes are invalid with a 16-bit operand size
+BYTE X86_Invalid_Op16_2[0x100] =
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
+ /* 1x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 8x */
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 9x */
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ax */
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
+ /* Cx */ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, /* Cx */
+ /* Dx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Dx */
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ex */
+ /* Fx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* Fx */
+};
+
+// Indicate which 1-byte opcodes are invalid with a 64-bit address size
+BYTE X86_Invalid_Addr64_1[0x100] =
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, /* 0x */
+ /* 1x */ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, /* 1x */
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, /* 2x */
+ /* 3x */ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, /* 3x */
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
+ /* 6x */ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 8x */
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* 9x */
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ax */
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
+ /* Cx */ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, /* Cx */
+ /* Dx */ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Dx */
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, /* Ex */
+ /* Fx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* Fx */
+};
+
+// Indicate which 2-byte opcodes are invalid with a 64-bit address size
+BYTE X86_Invalid_Addr64_2[0x100] =
+{
+ /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
+ /* 0x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
+ /* 1x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
+ /* 2x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
+ /* 3x */ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
+ /* 4x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
+ /* 5x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
+ /* 6x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 6x */
+ /* 7x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
+ /* 8x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 8x */
+ /* 9x */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 9x */
+ /* Ax */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ax */
+ /* Bx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
+ /* Cx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Cx */
+ /* Dx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Dx */
+ /* Ex */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Ex */
+ /* Fx */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* Fx */
+};
+
+#endif // DISASM_X86_TABLES
\ No newline at end of file
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/misc.c b/tools/glave/src/thirdparty/mhook/disasm-lib/misc.c
new file mode 100644
index 0000000..c5b0ac6
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/misc.c
@@ -0,0 +1,185 @@
+// Copyright (C) 2002, Matt Conover (mconover@gmail.com)
+#include "misc.h"
+
+BOOL IsHexChar(BYTE ch)
+{
+ switch (ch)
+ {
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ case '8': case '9':
+ case 'A': case 'a': case 'B': case 'b':
+ case 'C': case 'c': case 'D': case 'd':
+ case 'E': case 'e': case 'F': case 'f':
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
+
+// NOTE: caller must free the buffer returned
+BYTE *HexToBinary(char *Input, DWORD InputLength, DWORD *OutputLength)
+{
+ DWORD i, j, ByteCount = 0;
+ char temp_byte[3];
+ BYTE *p, *ByteString = NULL;
+
+ if (!InputLength || !OutputLength) return NULL;
+ else *OutputLength = 0;
+
+ while (*Input && isspace(*Input)) { Input++; InputLength--; }
+ if (!*Input) return NULL;
+ if (Input[0] == '\"') { Input++; InputLength--; }
+ p = (BYTE *)strchr(Input, '\"');
+ if (p) InputLength--;
+
+ if (InputLength > 2 && Input[2] == ' ') // assume spaces
+ {
+ for (i = 0; i < InputLength; i += 3)
+ {
+ while (i < InputLength && isspace(Input[i])) i++; // skip over extra space, \r, and \n
+ if (i >= InputLength) break;
+
+ if (!IsHexChar(Input[i]))
+ {
+ //fprintf(stderr, "ERROR: invalid hex character at offset %lu (0x%04x)\n", i, i);
+ goto abort;
+ }
+
+ if (i+1 >= InputLength || !Input[i+1])
+ {
+ //fprintf(stderr, "ERROR: hex string terminates unexpectedly at offset %lu (0x%04x)\n", i+1, i+1);
+ goto abort;
+ }
+
+ if (i+2 < InputLength && Input[i+2] && !isspace(Input[i+2]))
+ {
+ //fprintf(stderr, "ERROR: Hex string is malformed at offset %lu (0x%04x)\n", i, i);
+ //fprintf(stderr, "Found '%c' (0x%02x) instead of space\n", Input[i+2], Input[i+2]);
+ goto abort;
+ }
+
+ ByteCount++;
+ }
+
+ if (!ByteCount)
+ {
+ //fprintf(stderr, "Error: no input (byte count = 0)\n");
+ goto abort;
+ }
+
+ ByteString = malloc(ByteCount+1);
+ if (!ByteString)
+ {
+ //fprintf(stderr, "ERROR: failed to allocate %lu bytes\n", ByteCount);
+ goto abort;
+ }
+
+ memset(ByteString, 0, ByteCount+1);
+ for (i = 0, j = 0; j < ByteCount; i += 3, j++)
+ {
+ while (isspace(Input[i])) i++; // skip over extra space, \r, and \n
+ temp_byte[0] = Input[i];
+ temp_byte[1] = Input[i+1];
+ temp_byte[2] = 0;
+ ByteString[j] = (BYTE)strtoul(temp_byte, NULL, 16);
+ }
+ }
+ else if (InputLength > 2 && Input[0] == '\\')
+ {
+ for (i = 0; i < InputLength; i += 2)
+ {
+ if (Input[i] != '\\' || (Input[i+1] != 'x' && Input[i+1] != '0'))
+ {
+ //fprintf(stderr, "ERROR: invalid hex character at offset %lu (0x%04x)\n", i, i);
+ goto abort;
+ }
+ i += 2;
+
+ if (!IsHexChar(Input[i]))
+ {
+ //fprintf(stderr, "ERROR: invalid hex character at offset %lu (0x%04x)\n", i, i);
+ goto abort;
+ }
+ if (i+1 >= InputLength || !Input[i+1])
+ {
+ //fprintf(stderr, "ERROR: hex string terminates unexpectedly at offset %lu (0x%04x)\n", i+1, i+1);
+ goto abort;
+ }
+
+ ByteCount++;
+ }
+
+ if (!ByteCount)
+ {
+ //fprintf(stderr, "Error: no input (byte count = 0)\n");
+ goto abort;
+ }
+
+ ByteString = malloc(ByteCount+1);
+ if (!ByteString)
+ {
+ //fprintf(stderr, "ERROR: failed to allocate %lu bytes\n", ByteCount);
+ goto abort;
+ }
+
+ memset(ByteString, 0, ByteCount+1);
+ for (i = j = 0; j < ByteCount; i += 2, j++)
+ {
+ i += 2;
+ temp_byte[0] = Input[i];
+ temp_byte[1] = Input[i+1];
+ temp_byte[2] = 0;
+ ByteString[j] = (BYTE)strtoul(temp_byte, NULL, 16);
+ }
+ }
+ else // assume it is a hex string with no spaces with 2 bytes per character
+ {
+ for (i = 0; i < InputLength; i += 2)
+ {
+ if (!IsHexChar(Input[i]))
+ {
+ //fprintf(stderr, "ERROR: invalid hex character at offset %lu (0x%04x)\n", i, i);
+ goto abort;
+ }
+ if (i+1 >= InputLength || !Input[i+1])
+ {
+ //fprintf(stderr, "ERROR: hex string terminates unexpectedly at offset %lu (0x%04x)\n", i+1, i+1);
+ goto abort;
+ }
+
+ ByteCount++;
+ }
+
+ if (!ByteCount)
+ {
+ //fprintf(stderr, "Error: no input (byte count = 0)\n");
+ goto abort;
+ }
+
+ ByteString = malloc(ByteCount+1);
+ if (!ByteString)
+ {
+ //fprintf(stderr, "ERROR: failed to allocate %lu bytes\n", ByteCount);
+ goto abort;
+ }
+
+ memset(ByteString, 0, ByteCount+1);
+ for (i = 0, j = 0; j < ByteCount; i += 2, j++)
+ {
+ temp_byte[0] = Input[i];
+ temp_byte[1] = Input[i+1];
+ temp_byte[2] = 0;
+ ByteString[j] = (BYTE)strtoul(temp_byte, NULL, 16);
+ }
+ }
+
+ *OutputLength = ByteCount;
+ return ByteString;
+
+abort:
+ if (OutputLength) *OutputLength = 0;
+ if (ByteString) free(ByteString);
+ return NULL;
+}
+
diff --git a/tools/glave/src/thirdparty/mhook/disasm-lib/misc.h b/tools/glave/src/thirdparty/mhook/disasm-lib/misc.h
new file mode 100644
index 0000000..9c6783b
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/disasm-lib/misc.h
@@ -0,0 +1,56 @@
+// Copyright (C) 2002, Matt Conover (mconover@gmail.com)
+#ifndef MISC_H
+#define MISC_H
+#include "wintypes.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#ifdef __linux__
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#endif
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+// NOTE: start is inclusive, end is exclusive (as in start <= x < end)
+#define IS_IN_RANGE(x, s, e) \
+( \
+ ((ULONG_PTR)(x) == (ULONG_PTR)(s) && (ULONG_PTR)(x) == (ULONG_PTR)(e)) || \
+ ((ULONG_PTR)(x) >= (ULONG_PTR)(s) && (ULONG_PTR)(x) < (ULONG_PTR)(e)) \
+)
+
+#if _MSC_VER >= 1400
+#pragma warning(disable:4996)
+#endif
+
+#if defined(_WIN64)
+ #define VALID_ADDRESS_MAX 0x7FFEFFFFFFFFFFFF // Win64 specific
+ typedef unsigned __int64 ULONG_PTR, *PULONG_PTR;
+#else
+ #define VALID_ADDRESS_MAX 0x7FFEFFFF // Win32 specific
+ typedef unsigned long ULONG_PTR, *PULONG_PTR;
+#endif
+
+#ifndef DECLSPEC_ALIGN
+ #if (_MSC_VER >= 1300) && !defined(MIDL_PASS)
+ #define DECLSPEC_ALIGN(x) __declspec(align(x))
+ #else
+ #define DECLSPEC_ALIGN(x)
+ #endif
+#endif
+
+#define VALID_ADDRESS_MIN 0x10000 // Win32 specific
+#define IS_VALID_ADDRESS(a) IS_IN_RANGE(a, VALID_ADDRESS_MIN, VALID_ADDRESS_MAX+1)
+
+BOOL IsHexChar(BYTE ch);
+BYTE *HexToBinary(char *Input, DWORD InputLength, DWORD *OutputLength);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // MISC_H
diff --git a/tools/glave/src/thirdparty/mhook/mhook-lib/CMakeLists.txt b/tools/glave/src/thirdparty/mhook/mhook-lib/CMakeLists.txt
new file mode 100644
index 0000000..bb84735
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/mhook-lib/CMakeLists.txt
@@ -0,0 +1,31 @@
+project(mhook)
+cmake_minimum_required(VERSION 2.8)
+
+include("${SRC_DIR}/build_options.cmake")
+
+include_directories(
+ ${SRC_DIR}/thirdparty/mhook/mhook-lib
+ ${SRC_DIR}/thirdparty/mhook/disasm-lib
+ ${SRC_DIR}/glvcommon
+)
+
+set(SRC_LIST
+ mhook.c
+ mhook.h
+)
+
+set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
+
+if (NOT MSVC)
+ add_compiler_flag("-fPIC")
+endif()
+
+
+add_library(${PROJECT_NAME} STATIC ${SRC_LIST})
+target_link_libraries(${PROJECT_NAME}
+ disasm
+)
+
+build_options_finalize()
+
+set_target_properties(mhook PROPERTIES LINKER_LANGUAGE C)
diff --git a/tools/glave/src/thirdparty/mhook/mhook-lib/mhook.c b/tools/glave/src/thirdparty/mhook/mhook-lib/mhook.c
new file mode 100644
index 0000000..0d96d82
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/mhook-lib/mhook.c
@@ -0,0 +1,1076 @@
+//Copyright (c) 2007-2008, Marton Anka
+//
+//Permission is hereby granted, free of charge, to any person obtaining a
+//copy of this software and associated documentation files (the "Software"),
+//to deal in the Software without restriction, including without limitation
+//the rights to use, copy, modify, merge, publish, distribute, sublicense,
+//and/or sell copies of the Software, and to permit persons to whom the
+//Software is furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included
+//in all copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+//OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+//THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+//IN THE SOFTWARE.
+
+#include <wintypes.h>
+#if defined(WIN32)
+#include <tlhelp32.h>
+#elif defined(__linux__)
+#include <pthread.h>
+#include <wchar.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <errno.h>
+#define PAGE_EXECUTE_READWRITE (PROT_READ | PROT_EXEC | PROT_WRITE)
+#else
+#error unsupported platform
+#endif
+
+#include <stdio.h>
+#include "mhook.h"
+#include "../disasm-lib/disasm.h"
+
+//=========================================================================
+#ifndef cntof
+#define cntof(a) (sizeof(a)/sizeof(a[0]))
+#endif
+
+//=========================================================================
+#ifndef GOOD_HANDLE
+#define GOOD_HANDLE(a) ((a!=INVALID_HANDLE_VALUE)&&(a!=NULL))
+#endif
+
+//=========================================================================
+unsigned int gle()
+{
+#if defined(WIN32)
+ return GetLastError();
+#else
+ return errno;
+#endif
+}
+
+//=========================================================================
+#ifndef ODPRINTF
+
+#ifdef _DEBUG
+#define ODPRINTF(a) odprintf a
+#else
+#define ODPRINTF(a)
+#endif
+
+#ifdef __linux__
+inline void odprintf(PCSTR format, ...) {
+ va_list args;
+ va_start(args, format);
+ vprintf(format, args);
+ printf("\n");
+ va_end(args);
+}
+
+#else
+void __cdecl odprintf(char* format, ...) {
+ va_list args;
+ int len;
+ PSTR buf;
+ va_start(args, format);
+ len = _vscprintf(format, args);
+ if (len > 0) {
+ len += (1 + 2);
+ buf = (PSTR) malloc(len);
+ if (buf) {
+ len = vsprintf_s(buf, len, format, args);
+ if (len > 0) {
+ while (len && isspace(buf[len-1])) len--;
+ buf[len++] = '\r';
+ buf[len++] = '\n';
+ buf[len] = 0;
+ OutputDebugString(buf);
+ }
+ free(buf);
+ }
+ va_end(args);
+ }
+}
+#endif
+#endif //#ifndef ODPRINTF
+
+//=========================================================================
+#define MHOOKS_MAX_CODE_BYTES 32
+#define MHOOKS_MAX_RIPS 4
+
+//=========================================================================
+// The trampoline structure - stores every bit of info about a hook
+struct MHOOKS_TRAMPOLINE;
+typedef struct MHOOKS_TRAMPOLINE MHOOKS_TRAMPOLINE;
+struct MHOOKS_TRAMPOLINE {
+ PBYTE pSystemFunction; // the original system function
+ DWORD cbOverwrittenCode; // number of bytes overwritten by the jump
+ PBYTE pHookFunction; // the hook function that we provide
+ BYTE codeJumpToHookFunction[MHOOKS_MAX_CODE_BYTES]; // placeholder for code that jumps to the hook function
+ BYTE codeTrampoline[MHOOKS_MAX_CODE_BYTES]; // placeholder for code that holds the first few
+ // bytes from the system function and a jump to the remainder
+ // in the original location
+ BYTE codeUntouched[MHOOKS_MAX_CODE_BYTES]; // placeholder for unmodified original code
+ // (we patch IP-relative addressing)
+ MHOOKS_TRAMPOLINE* pPrevTrampoline; // When in the free list, thess are pointers to the prev and next entry.
+ MHOOKS_TRAMPOLINE* pNextTrampoline; // When not in the free list, this is a pointer to the prev and next trampoline in use.
+};
+
+//=========================================================================
+// The patch data structures - store info about rip-relative instructions
+// during hook placement
+struct MHOOKS_RIPINFO;
+typedef struct MHOOKS_RIPINFO MHOOKS_RIPINFO;
+struct MHOOKS_RIPINFO
+{
+ DWORD dwOffset;
+ S64 nDisplacement;
+};
+
+struct MHOOKS_PATCHDATA;
+typedef struct MHOOKS_PATCHDATA MHOOKS_PATCHDATA;
+struct MHOOKS_PATCHDATA
+{
+ S64 nLimitUp;
+ S64 nLimitDown;
+ DWORD nRipCnt;
+ MHOOKS_RIPINFO rips[MHOOKS_MAX_RIPS];
+};
+
+//=========================================================================
+// Global vars
+static BOOL g_bVarsInitialized = FALSE;
+#if defined(__linux__)
+static pthread_mutex_t g_cs;
+static void* g_hThreadHandles = NULL;
+#elif defined(WIN32)
+static CRITICAL_SECTION g_cs;
+static HANDLE* g_hThreadHandles = NULL;
+#endif
+static MHOOKS_TRAMPOLINE* g_pHooks = NULL;
+static MHOOKS_TRAMPOLINE* g_pFreeList = NULL;
+static DWORD g_nHooksInUse = 0;
+static DWORD g_nThreadHandles = 0;
+static BOOL g_bSuspendThreads = TRUE;
+static BOOL g_bMustGrabCritSec = TRUE;
+
+#define MHOOK_JMPSIZE 5
+#define MHOOK_MINALLOCSIZE 4096
+
+#ifdef WIN32
+//=========================================================================
+// Toolhelp defintions so the functions can be dynamically bound to
+typedef HANDLE (WINAPI * _CreateToolhelp32Snapshot)(
+ DWORD dwFlags,
+ DWORD th32ProcessID
+ );
+
+typedef BOOL (WINAPI * _Thread32First)(
+ HANDLE hSnapshot,
+ LPTHREADENTRY32 lpte
+ );
+
+typedef BOOL (WINAPI * _Thread32Next)(
+ HANDLE hSnapshot,
+ LPTHREADENTRY32 lpte
+ );
+
+//=========================================================================
+// Bring in the toolhelp functions from kernel32
+_CreateToolhelp32Snapshot fnCreateToolhelp32Snapshot = NULL;//(_CreateToolhelp32Snapshot) GetProcAddress(GetModuleHandle("kernel32"), "CreateToolhelp32Snapshot");
+_Thread32First fnThread32First = NULL;//(_Thread32First) GetProcAddress(GetModuleHandle("kernel32"), "Thread32First");
+_Thread32Next fnThread32Next = NULL;//(_Thread32Next) GetProcAddress(GetModuleHandle("kernel32"), "Thread32Next");
+
+void Mhook_Initialize()
+{
+ fnCreateToolhelp32Snapshot = (_CreateToolhelp32Snapshot) GetProcAddress(GetModuleHandle("kernel32"), "CreateToolhelp32Snapshot");
+ fnThread32First = (_Thread32First) GetProcAddress(GetModuleHandle("kernel32"), "Thread32First");
+ fnThread32Next = (_Thread32Next) GetProcAddress(GetModuleHandle("kernel32"), "Thread32Next");
+}
+#endif
+//=========================================================================
+// Internal function:
+//
+// Remove the trampoline from the specified list, updating the head pointer
+// if necessary.
+//=========================================================================
+static VOID ListRemove(MHOOKS_TRAMPOLINE** pListHead, MHOOKS_TRAMPOLINE* pNode) {
+ if (pNode->pPrevTrampoline) {
+ pNode->pPrevTrampoline->pNextTrampoline = pNode->pNextTrampoline;
+ }
+
+ if (pNode->pNextTrampoline) {
+ pNode->pNextTrampoline->pPrevTrampoline = pNode->pPrevTrampoline;
+ }
+
+ if ((*pListHead) == pNode) {
+ (*pListHead) = pNode->pNextTrampoline;
+ assert((*pListHead)->pPrevTrampoline == NULL);
+ }
+
+ pNode->pPrevTrampoline = NULL;
+ pNode->pNextTrampoline = NULL;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Prepend the trampoline from the specified list and update the head pointer.
+//=========================================================================
+static VOID ListPrepend(MHOOKS_TRAMPOLINE** pListHead, MHOOKS_TRAMPOLINE* pNode) {
+ pNode->pPrevTrampoline = NULL;
+ pNode->pNextTrampoline = (*pListHead);
+ if ((*pListHead)) {
+ (*pListHead)->pPrevTrampoline = pNode;
+ }
+ (*pListHead) = pNode;
+}
+
+//=========================================================================
+static VOID EnterCritSec() {
+ if (!g_bVarsInitialized) {
+#if defined(WIN32)
+ InitializeCriticalSection(&g_cs);
+#elif defined(__linux__)
+ pthread_mutex_init(&g_cs, NULL);
+#endif
+
+ g_bVarsInitialized = TRUE;
+ }
+#if defined(WIN32)
+ EnterCriticalSection(&g_cs);
+#elif defined(__linux__)
+ pthread_mutex_lock(&g_cs );
+#endif
+}
+
+//=========================================================================
+static VOID LeaveCritSec()
+{
+#if defined(WIN32)
+ LeaveCriticalSection(&g_cs);
+#elif defined(__linux__)
+ pthread_mutex_unlock(&g_cs );
+#endif
+}
+
+//=========================================================================
+static size_t GetAllocGranularity()
+{
+ // Always allocate in bulk, in case the system actually has a smaller allocation granularity than MINALLOCSIZE.
+#if defined(WIN32)
+ SYSTEM_INFO sSysInfo = {0};
+ GetSystemInfo(&sSysInfo);
+
+ return max(sSysInfo.dwAllocationGranularity, MHOOK_MINALLOCSIZE);
+#elif defined(__linux__)
+ // There is no situation where the allocation granularity is higher than the page size of the system
+ // on Linux, so you should be able to safely use PAGE_SIZE
+ return max(getpagesize(), MHOOK_MINALLOCSIZE);
+#endif
+}
+
+//=========================================================================
+// return of NULL means fatal error, return of (void *) -1 means couldn't alloc
+// the size at the requested area)
+static void * MapVirtualMem(const size_t allocSize, void * pbAlloc)
+{
+#if defined(WIN32)
+ // determine current state
+ MEMORY_BASIC_INFORMATION mbi;
+ ODPRINTF(("mhooks: BlockAlloc: Looking at address %p", pbAlloc));
+ if (!VirtualQuery(pbAlloc, &mbi, sizeof(mbi)))
+ return NULL;
+ // free & large enough?
+ if (mbi.State == MEM_FREE && mbi.RegionSize >= (unsigned)allocSize) {
+ // and then try to allocate it
+ return VirtualAlloc(pbAlloc, allocSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+ } else {
+ return (void *) -1;
+ }
+#elif defined(__linux__)
+ return mmap(pbAlloc, allocSize, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+#endif
+}
+
+//=========================================================================
+// Internal function:
+//
+// Skip over jumps that lead to the real function. Gets around import
+// jump tables, etc.
+//=========================================================================
+static PBYTE SkipJumps(PBYTE pbCode) {
+#ifdef _M_IX86_X64
+ if (pbCode[0] == 0xff && pbCode[1] == 0x25) {
+#ifdef _M_IX86
+ // on x86 we have an absolute pointer...
+ PBYTE pbTarget = *(PBYTE *)&pbCode[2];
+ // ... that shows us an absolute pointer.
+ return SkipJumps(*(PBYTE *)pbTarget);
+#elif defined _M_IX86_X64
+ // on x64 we have a 32-bit offset...
+ INT32 lOffset = *(INT32 *)&pbCode[2];
+ // ... that shows us an absolute pointer
+ return SkipJumps(*(PBYTE*)(pbCode + 6 + lOffset));
+#endif
+ } else if (pbCode[0] == 0xe9) {
+ // here the behavior is identical, we have...
+ // ...a 32-bit offset to the destination.
+ return SkipJumps(pbCode + 5 + *(INT32 *)&pbCode[1]);
+ } else if (pbCode[0] == 0xeb) {
+ // and finally an 8-bit offset to the destination
+ return SkipJumps(pbCode + 2 + *(CHAR *)&pbCode[1]);
+ }
+#else
+#error unsupported platform
+#endif
+ return pbCode;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Writes code at pbCode that jumps to pbJumpTo. Will attempt to do this
+// in as few bytes as possible. Important on x64 where the long jump
+// (0xff 0x25 ....) can take up 14 bytes.
+//=========================================================================
+static PBYTE EmitJump(PBYTE pbCode, PBYTE pbJumpTo) {
+#ifdef _M_IX86_X64
+ PBYTE pbJumpFrom = pbCode + 5;
+ SIZE_T cbDiff = pbJumpFrom > pbJumpTo ? pbJumpFrom - pbJumpTo : pbJumpTo - pbJumpFrom;
+ ODPRINTF(("mhooks: EmitJump: Jumping from %p to %p, diff is %p", pbJumpFrom, pbJumpTo, cbDiff));
+ if (cbDiff <= 0x7fff0000) {
+ pbCode[0] = 0xe9;
+ pbCode += 1;
+ *((PDWORD)pbCode) = (DWORD)(DWORD_PTR)(pbJumpTo - pbJumpFrom);
+ pbCode += sizeof(DWORD);
+ } else {
+ pbCode[0] = 0xff;
+ pbCode[1] = 0x25;
+ pbCode += 2;
+#ifdef _M_IX86
+ // on x86 we write an absolute address (just behind the instruction)
+ *((PDWORD)pbCode) = (DWORD)(DWORD_PTR)(pbCode + sizeof(DWORD));
+#elif defined _M_X64
+ // on x64 we write the relative address of the same location
+ *((PDWORD)pbCode) = (DWORD)0;
+#endif
+ pbCode += sizeof(DWORD);
+ *((PDWORD_PTR)pbCode) = (DWORD_PTR)(pbJumpTo);
+ pbCode += sizeof(DWORD_PTR);
+ }
+#else
+#error unsupported platform
+#endif
+ return pbCode;
+}
+
+
+//=========================================================================
+// Internal function:
+//
+// Round down to the next multiple of rndDown
+//=========================================================================
+static size_t RoundDown(size_t addr, size_t rndDown)
+{
+ return (addr / rndDown) * rndDown;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Will attempt allocate a block of memory within the specified range, as
+// near as possible to the specified function.
+//=========================================================================
+static MHOOKS_TRAMPOLINE* BlockAlloc(PBYTE pSystemFunction, PBYTE pbLower, PBYTE pbUpper) {
+ ptrdiff_t cAllocSize, bytesToOffset;
+ PBYTE pModuleGuess;
+ PBYTE pbAlloc;
+ MHOOKS_TRAMPOLINE* pRetVal = NULL;
+ int loopCount = 0;
+
+ cAllocSize = GetAllocGranularity();
+
+ pModuleGuess = (PBYTE) RoundDown((size_t)pSystemFunction, cAllocSize);
+
+ for (pbAlloc = pModuleGuess; pbLower < pbAlloc && pbAlloc < pbUpper; ++loopCount) {
+ pRetVal = (MHOOKS_TRAMPOLINE*) MapVirtualMem(cAllocSize, pbAlloc);
+ if(!pRetVal)
+ break;
+ if (pRetVal != (void *) -1) {
+ size_t s;
+ size_t trampolineCount = cAllocSize / sizeof(MHOOKS_TRAMPOLINE);
+ ODPRINTF(("mhooks: BlockAlloc: Allocated block at %p as %d trampolines", pRetVal, trampolineCount));
+
+ pRetVal[0].pPrevTrampoline = NULL;
+ pRetVal[0].pNextTrampoline = &pRetVal[1];
+
+ // prepare them by having them point down the line at the next entry
+ for (s = 1; s < trampolineCount; ++s) {
+ pRetVal[s].pPrevTrampoline = &pRetVal[s - 1];
+ pRetVal[s].pNextTrampoline = &pRetVal[s + 1];
+ }
+
+ // last entry points to the current head of the free list
+ pRetVal[trampolineCount - 1].pNextTrampoline = g_pFreeList;
+ break;
+ }
+
+ // This is a spiral, should be -1, 1, -2, 2, -3, 3, etc. (* cAllocSize)
+ bytesToOffset = (cAllocSize * (loopCount + 1) * ((loopCount % 2 == 0) ? -1 : 1));
+ pbAlloc = pbAlloc + bytesToOffset;
+ }
+
+ return pRetVal;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Will try to allocate a big block of memory inside the required range.
+//=========================================================================
+static MHOOKS_TRAMPOLINE* FindTrampolineInRange(PBYTE pLower, PBYTE pUpper) {
+
+ // This is a standard free list, except we're doubly linked to deal with soem return shenanigans.
+ MHOOKS_TRAMPOLINE* curEntry = g_pFreeList;
+ if (!g_pFreeList) {
+ return NULL;
+ }
+
+ while (curEntry) {
+ if ((MHOOKS_TRAMPOLINE*) pLower < curEntry && curEntry < (MHOOKS_TRAMPOLINE*) pUpper) {
+ ListRemove(&g_pFreeList, curEntry);
+
+ return curEntry;
+ }
+
+ curEntry = curEntry->pNextTrampoline;
+ }
+
+ return NULL;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Will try to allocate the trampoline structure within 2 gigabytes of
+// the target function.
+//=========================================================================
+static MHOOKS_TRAMPOLINE* TrampolineAlloc(PBYTE pSystemFunction, S64 nLimitUp, S64 nLimitDown) {
+
+ MHOOKS_TRAMPOLINE* pTrampoline = NULL;
+ PBYTE pUpper;
+ // determine lower and upper bounds for the allocation locations.
+ // in the basic scenario this is +/- 2GB but IP-relative instructions
+ // found in the original code may require a smaller window.
+ PBYTE pLower = pSystemFunction + nLimitUp;
+ pLower = pLower < (PBYTE)(DWORD_PTR)0x0000000080000000 ?
+ (PBYTE)(0x1) : (PBYTE)(pLower - (PBYTE)0x7fff0000);
+ pUpper = pSystemFunction + nLimitDown;
+ pUpper = pUpper < (PBYTE)(DWORD_PTR)0xffffffff80000000 ?
+ (PBYTE)(pUpper + 0x7ff80000) : (PBYTE)(DWORD_PTR)0xfffffffffff80000;
+ ODPRINTF(("mhooks: TrampolineAlloc: Allocating for %p between %p and %p", pSystemFunction, pLower, pUpper));
+
+ // try to find a trampoline in the specified range
+ pTrampoline = FindTrampolineInRange(pLower, pUpper);
+ if (!pTrampoline) {
+ // if it we can't find it, then we need to allocate a new block and
+ // try again. Just fail if that doesn't work
+ g_pFreeList = BlockAlloc(pSystemFunction, pLower, pUpper);
+ pTrampoline = FindTrampolineInRange(pLower, pUpper);
+ }
+
+ // found and allocated a trampoline?
+ if (pTrampoline) {
+ ListPrepend(&g_pHooks, pTrampoline);
+ }
+
+ return pTrampoline;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Return the internal trampoline structure that belongs to a hooked function.
+//=========================================================================
+static MHOOKS_TRAMPOLINE* TrampolineGet(PBYTE pHookedFunction) {
+ MHOOKS_TRAMPOLINE* pCurrent = g_pHooks;
+
+ while (pCurrent) {
+ if (pCurrent->pHookFunction == pHookedFunction) {
+ return pCurrent;
+ }
+
+ pCurrent = pCurrent->pNextTrampoline;
+ }
+
+ return NULL;
+}
+
+static void * GetCurProcess()
+{
+#ifdef WIN32
+ return (void *) GetCurrentProcess();
+#else
+ return(NULL);
+#endif
+}
+
+static void FlushCache(void * process, void * address, size_t size)
+{
+#if defined(WIN32)
+ FlushInstructionCache(process, address, size);
+#elif defined(__linux__)
+ // TODO do we really need to flush the Instruction cache on x86 on Linux?
+#else
+#error unsupported platform
+#endif
+}
+
+static BOOL MemProtect(void * process, void * address, size_t size, DWORD newProtect, DWORD *oldProtect)
+{
+#if defined(WIN32)
+ return (VirtualProtectEx(process, address, size, newProtect, oldProtect));
+#elif defined(__linux__)
+ *oldProtect = PROT_READ | PROT_EXEC;
+ if (mprotect(address, size, newProtect))
+ return TRUE;
+ else
+ return FALSE;
+#else
+#error unsupported platform
+#endif
+}
+//=========================================================================
+// Internal function:
+//
+// Free a trampoline structure.
+//=========================================================================
+static VOID TrampolineFree(MHOOKS_TRAMPOLINE* pTrampoline, BOOL bNeverUsed) {
+ ListRemove(&g_pHooks, pTrampoline);
+
+ // If a thread could feasinbly have some of our trampoline code
+ // on its stack and we yank the region from underneath it then it will
+ // surely crash upon returning. So instead of freeing the
+ // memory we just let it leak. Ugly, but safe.
+ if (bNeverUsed) {
+ ListPrepend(&g_pFreeList, pTrampoline);
+ }
+
+ g_nHooksInUse--;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Suspend a given thread and try to make sure that its instruction
+// pointer is not in the given range.
+//=========================================================================
+static HANDLE SuspendOneThread(DWORD dwThreadId, PBYTE pbCode, DWORD cbBytes) {
+ // open the thread
+ HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, dwThreadId);
+ if (GOOD_HANDLE(hThread)) {
+ // attempt suspension
+ DWORD dwSuspendCount = SuspendThread(hThread);
+ if (dwSuspendCount != -1) {
+ // see where the IP is
+ CONTEXT ctx;
+ int nTries = 0;
+ ctx.ContextFlags = CONTEXT_CONTROL;
+
+ while (GetThreadContext(hThread, &ctx)) {
+#ifdef _M_IX86
+ PBYTE pIp = (PBYTE)(DWORD_PTR)ctx.Eip;
+#elif defined _M_X64
+ PBYTE pIp = (PBYTE)(DWORD_PTR)ctx.Rip;
+#endif
+ if (pIp >= pbCode && pIp < (pbCode + cbBytes)) {
+ if (nTries < 3) {
+ // oops - we should try to get the instruction pointer out of here.
+ ODPRINTF(("mhooks: SuspendOneThread: suspended thread %d - IP is at %p - IS COLLIDING WITH CODE", dwThreadId, pIp));
+ ResumeThread(hThread);
+ Sleep(100);
+ SuspendThread(hThread);
+ nTries++;
+ } else {
+ // we gave it all we could. (this will probably never
+ // happen - unless the thread has already been suspended
+ // to begin with)
+ ODPRINTF(("mhooks: SuspendOneThread: suspended thread %d - IP is at %p - IS COLLIDING WITH CODE - CAN'T FIX", dwThreadId, pIp));
+ ResumeThread(hThread);
+ CloseHandle(hThread);
+ hThread = NULL;
+ break;
+ }
+ } else {
+ // success, the IP is not conflicting
+ ODPRINTF(("mhooks: SuspendOneThread: Successfully suspended thread %d - IP is at %p", dwThreadId, pIp));
+ break;
+ }
+ }
+ } else {
+ // couldn't suspend
+ CloseHandle(hThread);
+ hThread = NULL;
+ }
+ }
+ return hThread;
+}
+
+//=========================================================================
+// Internal function:
+//
+// Resumes all previously suspended threads in the current process.
+//=========================================================================
+static VOID ResumeOtherThreads() {
+ DWORD i;
+ // make sure things go as fast as possible
+ INT nOriginalPriority = GetThreadPriority(GetCurrentThread());
+ SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
+ // go through our list
+ for (i=0; i<g_nThreadHandles; i++) {
+ // and resume & close thread handles
+ ResumeThread(g_hThreadHandles[i]);
+ CloseHandle(g_hThreadHandles[i]);
+ }
+ // clean up
+ free(g_hThreadHandles);
+ g_hThreadHandles = NULL;
+ g_nThreadHandles = 0;
+ SetThreadPriority(GetCurrentThread(), nOriginalPriority);
+}
+
+//=========================================================================
+// Internal function:
+//
+// Suspend all threads in this process while trying to make sure that their
+// instruction pointer is not in the given range.
+//=========================================================================
+static BOOL SuspendOtherThreads(PBYTE pbCode, DWORD cbBytes) {
+ BOOL bRet = FALSE;
+ HANDLE hSnap;
+ // make sure we're the most important thread in the process
+ INT nOriginalPriority = GetThreadPriority(GetCurrentThread());
+ SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
+ // get a view of the threads in the system
+ hSnap = fnCreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, GetCurrentProcessId());
+ if (GOOD_HANDLE(hSnap)) {
+ THREADENTRY32 te;
+ DWORD nThreadsInProcess;
+ te.dwSize = sizeof(te);
+ // count threads in this process (except for ourselves)
+ nThreadsInProcess = 0;
+ if (fnThread32First(hSnap, &te)) {
+ do {
+ if (te.th32OwnerProcessID == GetCurrentProcessId()) {
+ if (te.th32ThreadID != GetCurrentThreadId()) {
+ nThreadsInProcess++;
+ }
+ }
+ te.dwSize = sizeof(te);
+ } while(fnThread32Next(hSnap, &te));
+ }
+ ODPRINTF(("mhooks: SuspendOtherThreads: counted %d other threads", nThreadsInProcess));
+ if (nThreadsInProcess) {
+ // alloc buffer for the handles we really suspended
+ g_hThreadHandles = (HANDLE*)malloc(nThreadsInProcess*sizeof(HANDLE));
+ if (g_hThreadHandles) {
+ DWORD nCurrentThread = 0;
+ BOOL bFailed = FALSE;
+
+ ZeroMemory(g_hThreadHandles, nThreadsInProcess*sizeof(HANDLE));
+ te.dwSize = sizeof(te);
+ // go through every thread
+ if (fnThread32First(hSnap, &te)) {
+ do {
+ if (te.th32OwnerProcessID == GetCurrentProcessId()) {
+ if (te.th32ThreadID != GetCurrentThreadId()) {
+ // attempt to suspend it
+ g_hThreadHandles[nCurrentThread] = SuspendOneThread(te.th32ThreadID, pbCode, cbBytes);
+ if (GOOD_HANDLE(g_hThreadHandles[nCurrentThread])) {
+ ODPRINTF(("mhooks: SuspendOtherThreads: successfully suspended %d", te.th32ThreadID));
+ nCurrentThread++;
+ } else {
+ ODPRINTF(("mhooks: SuspendOtherThreads: error while suspending thread %d: %d", te.th32ThreadID, gle()));
+ // TODO: this might not be the wisest choice
+ // but we can choose to ignore failures on
+ // thread suspension. It's pretty unlikely that
+ // we'll fail - and even if we do, the chances
+ // of a thread's IP being in the wrong place
+ // is pretty small.
+ // bFailed = TRUE;
+ }
+ }
+ }
+ te.dwSize = sizeof(te);
+ } while(fnThread32Next(hSnap, &te) && !bFailed);
+ }
+ g_nThreadHandles = nCurrentThread;
+ bRet = !bFailed;
+ }
+ }
+ CloseHandle(hSnap);
+ //TODO: we might want to have another pass to make sure all threads
+ // in the current process (including those that might have been
+ // created since we took the original snapshot) have been
+ // suspended.
+ } else {
+ ODPRINTF(("mhooks: SuspendOtherThreads: can't CreateToolhelp32Snapshot: %d", gle()));
+ }
+ SetThreadPriority(GetCurrentThread(), nOriginalPriority);
+ if (!bRet) {
+ ODPRINTF(("mhooks: SuspendOtherThreads: Had a problem (or not running multithreaded), resuming all threads."));
+ ResumeOtherThreads();
+ }
+ return bRet;
+}
+
+//=========================================================================
+// if IP-relative addressing has been detected, fix up the code so the
+// offset points to the original location
+static void FixupIPRelativeAddressing(PBYTE pbNew, PBYTE pbOriginal, MHOOKS_PATCHDATA* pdata)
+{
+#if defined _M_X64
+ S64 diff = pbNew - pbOriginal;
+ DWORD i;
+ for (i = 0; i < pdata->nRipCnt; i++) {
+ DWORD dwNewDisplacement = (DWORD)(pdata->rips[i].nDisplacement - diff);
+ ODPRINTF(("mhooks: fixing up RIP instruction operand for code at 0x%p: "
+ "old displacement: 0x%8.8x, new displacement: 0x%8.8x",
+ pbNew + pdata->rips[i].dwOffset,
+ (DWORD)pdata->rips[i].nDisplacement,
+ dwNewDisplacement));
+ *(PDWORD)(pbNew + pdata->rips[i].dwOffset) = dwNewDisplacement;
+ }
+#endif
+}
+
+//=========================================================================
+// Examine the machine code at the target function's entry point, and
+// skip bytes in a way that we'll always end on an instruction boundary.
+// We also detect branches and subroutine calls (as well as returns)
+// at which point disassembly must stop.
+// Finally, detect and collect information on IP-relative instructions
+// that we can patch.
+static DWORD DisassembleAndSkip(PVOID pFunction, DWORD dwMinLen, MHOOKS_PATCHDATA* pdata) {
+ DWORD dwRet = 0;
+
+#ifdef _M_IX86
+ ARCHITECTURE_TYPE arch = ARCH_X86;
+#elif defined _M_IX86_X64
+ ARCHITECTURE_TYPE arch = ARCH_X64;
+#else
+ #error unsupported platform
+#endif
+ DISASSEMBLER dis;
+ pdata->nLimitDown = 0;
+ pdata->nLimitUp = 0;
+ pdata->nRipCnt = 0;
+ if (InitDisassembler(&dis, arch)) {
+ INSTRUCTION* pins = NULL;
+ U8* pLoc = (U8*)pFunction;
+ DWORD dwFlags = DISASM_DECODE | DISASM_DISASSEMBLE | DISASM_ALIGNOUTPUT;
+
+ ODPRINTF(("mhooks: DisassembleAndSkip: Disassembling %p", pLoc));
+ while ( (dwRet < dwMinLen) && (pins = GetInstruction(&dis, (ULONG_PTR)pLoc, pLoc, dwFlags)) ) {
+#if defined _M_IX86_X64
+ BOOL bProcessRip;
+#endif
+ ODPRINTF(("mhooks: DisassembleAndSkip: %p: %s", pLoc, pins->String));
+ if (pins->Type == ITYPE_RET ) break;
+ if (pins->Type == ITYPE_BRANCH ) break;
+ if (pins->Type == ITYPE_BRANCHCC) break;
+ if (pins->Type == ITYPE_CALL ) break;
+ if (pins->Type == ITYPE_CALLCC ) break;
+
+ #if defined _M_IX86_X64
+ bProcessRip = FALSE;
+ // mov or lea to register from rip+imm32
+ if ((pins->Type == ITYPE_MOV || pins->Type == ITYPE_LEA) && (pins->X86.Relative) &&
+ (pins->X86.OperandSize == 8) && (pins->OperandCount == 2) &&
+ (pins->Operands[1].Flags & OP_IPREL) && (pins->Operands[1].Register == AMD64_REG_RIP))
+ {
+ // rip-addressing "mov reg, [rip+imm32]"
+ ODPRINTF(("mhooks: DisassembleAndSkip: found OP_IPREL on operand %d with displacement 0x%x (in memory: 0x%x)", 1, pins->X86.Displacement, *(PDWORD)(pLoc+3)));
+ bProcessRip = TRUE;
+ }
+ // mov or lea to rip+imm32 from register
+ else if ((pins->Type == ITYPE_MOV || pins->Type == ITYPE_LEA) && (pins->X86.Relative) &&
+ (pins->X86.OperandSize == 8) && (pins->OperandCount == 2) &&
+ (pins->Operands[0].Flags & OP_IPREL) && (pins->Operands[0].Register == AMD64_REG_RIP))
+ {
+ // rip-addressing "mov [rip+imm32], reg"
+ ODPRINTF(("mhooks: DisassembleAndSkip: found OP_IPREL on operand %d with displacement 0x%x (in memory: 0x%x)", 0, pins->X86.Displacement, *(PDWORD)(pLoc+3)));
+ bProcessRip = TRUE;
+ }
+ else if ( (pins->OperandCount >= 1) && (pins->Operands[0].Flags & OP_IPREL) )
+ {
+ DWORD i;
+ // unsupported rip-addressing
+ ODPRINTF(("mhooks: DisassembleAndSkip: found unsupported OP_IPREL on operand %d", 0));
+ // dump instruction bytes to the debug output
+ for (i=0; i<pins->Length; i++) {
+ ODPRINTF(("mhooks: DisassembleAndSkip: instr byte %2.2d: 0x%2.2x", i, pLoc[i]));
+ }
+ break;
+ }
+ else if ( (pins->OperandCount >= 2) && (pins->Operands[1].Flags & OP_IPREL) )
+ {
+ DWORD i;
+ // unsupported rip-addressing
+ ODPRINTF(("mhooks: DisassembleAndSkip: found unsupported OP_IPREL on operand %d", 1));
+ // dump instruction bytes to the debug output
+ for (i=0; i<pins->Length; i++) {
+ ODPRINTF(("mhooks: DisassembleAndSkip: instr byte %2.2d: 0x%2.2x", i, pLoc[i]));
+ }
+ break;
+ }
+ else if ( (pins->OperandCount >= 3) && (pins->Operands[2].Flags & OP_IPREL) )
+ {
+ DWORD i;
+ // unsupported rip-addressing
+ ODPRINTF(("mhooks: DisassembleAndSkip: found unsupported OP_IPREL on operand %d", 2));
+ // dump instruction bytes to the debug output
+ for (i=0; i<pins->Length; i++) {
+ ODPRINTF(("mhooks: DisassembleAndSkip: instr byte %2.2d: 0x%2.2x", i, pLoc[i]));
+ }
+ break;
+ }
+ // follow through with RIP-processing if needed
+ if (bProcessRip) {
+ // calculate displacement relative to function start
+ S64 nAdjustedDisplacement = pins->X86.Displacement + (pLoc - (U8*)pFunction);
+ // store displacement values furthest from zero (both positive and negative)
+ if (nAdjustedDisplacement < pdata->nLimitDown)
+ pdata->nLimitDown = nAdjustedDisplacement;
+ if (nAdjustedDisplacement > pdata->nLimitUp)
+ pdata->nLimitUp = nAdjustedDisplacement;
+ // store patch info
+ if (pdata->nRipCnt < MHOOKS_MAX_RIPS) {
+ pdata->rips[pdata->nRipCnt].dwOffset = dwRet + 3;
+ pdata->rips[pdata->nRipCnt].nDisplacement = pins->X86.Displacement;
+ pdata->nRipCnt++;
+ } else {
+ // no room for patch info, stop disassembly
+ break;
+ }
+ }
+ #endif
+
+ dwRet += pins->Length;
+ pLoc += pins->Length;
+ }
+
+ CloseDisassembler(&dis);
+ }
+
+ return dwRet;
+}
+
+//=========================================================================
+BOOL Mhook_SetHook(PVOID *ppSystemFunction, PVOID pHookFunction) {
+ DWORD dwInstructionLength;
+ MHOOKS_TRAMPOLINE* pTrampoline = NULL;
+ PVOID pSystemFunction = *ppSystemFunction;
+ MHOOKS_PATCHDATA patchdata;
+ patchdata.nLimitDown= 0;
+ patchdata.nLimitUp = 0;
+ patchdata.nRipCnt = 0;
+
+ // ensure thread-safety
+ if (g_bMustGrabCritSec) {
+ EnterCritSec();
+ }
+ ODPRINTF(("mhooks: Mhook_SetHook: Started on the job: %p / %p", pSystemFunction, pHookFunction));
+ // find the real functions (jump over jump tables, if any)
+ pSystemFunction = SkipJumps((PBYTE)pSystemFunction);
+ pHookFunction = SkipJumps((PBYTE)pHookFunction);
+ ODPRINTF(("mhooks: Mhook_SetHook: Started on the job: %p / %p", pSystemFunction, pHookFunction));
+ // figure out the length of the overwrite zone
+
+ dwInstructionLength = DisassembleAndSkip(pSystemFunction, MHOOK_JMPSIZE, &patchdata);
+ if (dwInstructionLength >= MHOOK_JMPSIZE) {
+ ODPRINTF(("mhooks: Mhook_SetHook: disassembly signals %d bytes", dwInstructionLength));
+ // suspend every other thread in this process, and make sure their IP
+ // is not in the code we're about to overwrite.
+ // Note: The caller might've told us not to worry about this, if they're sure no other threads
+ // could be running--for example when hooking functions in a suspended process.
+ if (g_bSuspendThreads) {
+ SuspendOtherThreads((PBYTE)pSystemFunction, dwInstructionLength);
+ }
+ // allocate a trampoline structure (TODO: it is pretty wasteful to get
+ // VirtualAlloc to grab chunks of memory smaller than 100 bytes)
+ pTrampoline = TrampolineAlloc((PBYTE)pSystemFunction, patchdata.nLimitUp, patchdata.nLimitDown);
+ if (pTrampoline) {
+ // open ourselves so we can VirtualProtectEx
+ void * hProc = GetCurProcess();
+ DWORD dwOldProtectSystemFunction = 0;
+ DWORD dwOldProtectTrampolineFunction = 0;
+ ODPRINTF(("mhooks: Mhook_SetHook: allocated structure at %p", pTrampoline));
+ // set the system function to PAGE_EXECUTE_READWRITE
+ if (MemProtect(hProc, pSystemFunction, dwInstructionLength, PAGE_EXECUTE_READWRITE, &dwOldProtectSystemFunction)) {
+ ODPRINTF(("mhooks: Mhook_SetHook: readwrite set on system function"));
+ // mark our trampoline buffer to PAGE_EXECUTE_READWRITE
+ if (MemProtect(hProc, pTrampoline, sizeof(MHOOKS_TRAMPOLINE), PAGE_EXECUTE_READWRITE, &dwOldProtectTrampolineFunction)) {
+ PBYTE pbCode;
+ DWORD i;
+ DWORD_PTR dwDistance;
+ ODPRINTF(("mhooks: Mhook_SetHook: readwrite set on trampoline structure"));
+
+ // create our trampoline function
+ pbCode = pTrampoline->codeTrampoline;
+ // save original code..
+ for (i = 0; i<dwInstructionLength; i++) {
+ pTrampoline->codeUntouched[i] = pbCode[i] = ((PBYTE)pSystemFunction)[i];
+ }
+ pbCode += dwInstructionLength;
+ // plus a jump to the continuation in the original location
+ pbCode = EmitJump(pbCode, ((PBYTE)pSystemFunction) + dwInstructionLength);
+ ODPRINTF(("mhooks: Mhook_SetHook: updated the trampoline"));
+
+ // fix up any IP-relative addressing in the code
+ FixupIPRelativeAddressing(pTrampoline->codeTrampoline, (PBYTE)pSystemFunction, &patchdata);
+
+ dwDistance = (PBYTE)pHookFunction < (PBYTE)pSystemFunction ?
+ (PBYTE)pSystemFunction - (PBYTE)pHookFunction : (PBYTE)pHookFunction - (PBYTE)pSystemFunction;
+ if (dwDistance > 0x7fff0000) {
+ // create a stub that jumps to the replacement function.
+ // we need this because jumping from the API to the hook directly
+ // will be a long jump, which is 14 bytes on x64, and we want to
+ // avoid that - the API may or may not have room for such stuff.
+ // (remember, we only have 5 bytes guaranteed in the API.)
+ // on the other hand we do have room, and the trampoline will always be
+ // within +/- 2GB of the API, so we do the long jump in there.
+ // the API will jump to the "reverse trampoline" which
+ // will jump to the user's hook code.
+ pbCode = pTrampoline->codeJumpToHookFunction;
+ pbCode = EmitJump(pbCode, (PBYTE)pHookFunction);
+ ODPRINTF(("mhooks: Mhook_SetHook: created reverse trampoline"));
+ FlushCache(hProc, pTrampoline->codeJumpToHookFunction,
+ pbCode - pTrampoline->codeJumpToHookFunction);
+
+ // update the API itself
+ pbCode = (PBYTE)pSystemFunction;
+ pbCode = EmitJump(pbCode, pTrampoline->codeJumpToHookFunction);
+ } else {
+ // the jump will be at most 5 bytes so we can do it directly
+ // update the API itself
+ pbCode = (PBYTE)pSystemFunction;
+ pbCode = EmitJump(pbCode, (PBYTE)pHookFunction);
+ }
+
+ // update data members
+ pTrampoline->cbOverwrittenCode = dwInstructionLength;
+ pTrampoline->pSystemFunction = (PBYTE)pSystemFunction;
+ pTrampoline->pHookFunction = (PBYTE)pHookFunction;
+
+ // flush instruction cache and restore original protection
+ FlushCache(hProc, pTrampoline->codeTrampoline, dwInstructionLength);
+ MemProtect(hProc, pTrampoline, sizeof(MHOOKS_TRAMPOLINE), dwOldProtectTrampolineFunction, &dwOldProtectTrampolineFunction);
+ } else {
+ ODPRINTF(("mhooks: Mhook_SetHook: failed VirtualProtectEx 2: %d", gle()));
+ }
+ // flush instruction cache and restore original protection
+ FlushCache(hProc, pSystemFunction, dwInstructionLength);
+ MemProtect(hProc, pSystemFunction, dwInstructionLength, dwOldProtectSystemFunction, &dwOldProtectSystemFunction);
+ } else {
+ ODPRINTF(("mhooks: Mhook_SetHook: failed VirtualProtectEx 1: %d", gle()));
+ }
+ if (pTrampoline->pSystemFunction) {
+ // this is what the application will use as the entry point
+ // to the "original" unhooked function.
+ *ppSystemFunction = pTrampoline->codeTrampoline;
+ ODPRINTF(("mhooks: Mhook_SetHook: Hooked the function!"));
+ } else {
+ // if we failed discard the trampoline (forcing VirtualFree)
+ TrampolineFree(pTrampoline, TRUE);
+ pTrampoline = NULL;
+ }
+ }
+ // resume everybody else
+ if (g_bSuspendThreads) {
+ ResumeOtherThreads();
+ }
+ } else {
+ ODPRINTF(("mhooks: disassembly signals %u bytes (unacceptable)", dwInstructionLength));
+ }
+ if (g_bMustGrabCritSec) {
+ LeaveCritSec();
+ }
+ return (pTrampoline != NULL);
+}
+
+//=========================================================================
+BOOL Mhook_Unhook(PVOID *ppHookedFunction) {
+ BOOL bRet = FALSE;
+ MHOOKS_TRAMPOLINE* pTrampoline;
+ ODPRINTF(("mhooks: Mhook_Unhook: %p", *ppHookedFunction));
+ if (g_bMustGrabCritSec) {
+ EnterCritSec();
+ }
+ // get the trampoline structure that corresponds to our function
+ pTrampoline = TrampolineGet((PBYTE)*ppHookedFunction);
+ if (pTrampoline) {
+ void * hProc;
+ DWORD dwOldProtectSystemFunction;
+ // make sure nobody's executing code where we're about to overwrite a few bytes
+ if (g_bSuspendThreads) {
+ SuspendOtherThreads(pTrampoline->pSystemFunction, pTrampoline->cbOverwrittenCode);
+ }
+ ODPRINTF(("mhooks: Mhook_Unhook: found struct at %p", pTrampoline));
+ // open ourselves so we can VirtualProtectEx
+ hProc = GetCurProcess();
+ dwOldProtectSystemFunction = 0;
+ // make memory writable
+ if (MemProtect(hProc, pTrampoline->pSystemFunction, pTrampoline->cbOverwrittenCode, PAGE_EXECUTE_READWRITE, &dwOldProtectSystemFunction)) {
+ DWORD i;
+ PBYTE pbCode = (PBYTE)pTrampoline->pSystemFunction;
+ ODPRINTF(("mhooks: Mhook_Unhook: readwrite set on system function"));
+ for (i = 0; i<pTrampoline->cbOverwrittenCode; i++) {
+ pbCode[i] = pTrampoline->codeUntouched[i];
+ }
+ // flush instruction cache and make memory unwritable
+ FlushCache(hProc, pTrampoline->pSystemFunction, pTrampoline->cbOverwrittenCode);
+ MemProtect(hProc, pTrampoline->pSystemFunction, pTrampoline->cbOverwrittenCode, dwOldProtectSystemFunction, &dwOldProtectSystemFunction);
+ // return the original function pointer
+ *ppHookedFunction = pTrampoline->pSystemFunction;
+ bRet = TRUE;
+ ODPRINTF(("mhooks: Mhook_Unhook: sysfunc: %p", *ppHookedFunction));
+ // free the trampoline while not really discarding it from memory
+ TrampolineFree(pTrampoline, FALSE);
+ ODPRINTF(("mhooks: Mhook_Unhook: unhook successful"));
+ } else {
+ ODPRINTF(("mhooks: Mhook_Unhook: failed VirtualProtectEx 1: %d", gle()));
+ }
+ if (g_bSuspendThreads) {
+ // make the other guys runnable
+ ResumeOtherThreads();
+ }
+ }
+ if (g_bMustGrabCritSec) {
+ LeaveCritSec();
+ }
+ return bRet;
+}
+
+//=========================================================================
+VOID Mhook_BeginMultiOperation(BOOL bStillSuspendThreads)
+{
+ EnterCritSec();
+ g_bSuspendThreads = bStillSuspendThreads;
+ g_bMustGrabCritSec = FALSE;
+}
+
+VOID Mhook_EndMultiOperation()
+{
+ g_bMustGrabCritSec = TRUE;
+ g_bSuspendThreads = TRUE;
+ LeaveCritSec();
+}
diff --git a/tools/glave/src/thirdparty/mhook/mhook-lib/mhook.h b/tools/glave/src/thirdparty/mhook/mhook-lib/mhook.h
new file mode 100644
index 0000000..d4ce638
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/mhook-lib/mhook.h
@@ -0,0 +1,56 @@
+//Copyright (c) 2007-2008, Marton Anka
+//
+//Permission is hereby granted, free of charge, to any person obtaining a
+//copy of this software and associated documentation files (the "Software"),
+//to deal in the Software without restriction, including without limitation
+//the rights to use, copy, modify, merge, publish, distribute, sublicense,
+//and/or sell copies of the Software, and to permit persons to whom the
+//Software is furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included
+//in all copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+//OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+//THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+//IN THE SOFTWARE.
+#pragma once
+
+#if defined(__linux__)
+#if defined(__i386__)
+#define _M_IX86
+#elif defined(__x86_64__)
+#define _M_IX86_X64
+#endif
+#elif defined(WIN32)
+#ifdef _M_IX86
+#define _M_IX86_X64
+#elif defined _M_X64
+#define _M_IX86_X64
+#endif
+#endif
+
+#include "wintypes.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Mhook_Initialize();
+
+BOOL Mhook_SetHook(PVOID *ppSystemFunction, PVOID pHookFunction);
+BOOL Mhook_Unhook(PVOID *ppHookedFunction);
+
+// If you'll be hooking (or unhooking) a large number of functions, you can
+// make it faster by wrapping them all with one call to Begin/End MultiOperation
+// bStillSuspendThreads should be true if you need each call to SetHook to try
+// and suspend other threads, and FALSE if you know the other threads will already
+// be suspended.
+VOID Mhook_BeginMultiOperation(BOOL bStillSuspendThreads);
+VOID Mhook_EndMultiOperation();
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/tools/glave/src/thirdparty/mhook/mhook-test.cpp b/tools/glave/src/thirdparty/mhook/mhook-test.cpp
new file mode 100644
index 0000000..79dc767
--- /dev/null
+++ b/tools/glave/src/thirdparty/mhook/mhook-test.cpp
@@ -0,0 +1,218 @@
+//Copyright (c) 2007-2008, Marton Anka
+//
+//Permission is hereby granted, free of charge, to any person obtaining a
+//copy of this software and associated documentation files (the "Software"),
+//to deal in the Software without restriction, including without limitation
+//the rights to use, copy, modify, merge, publish, distribute, sublicense,
+//and/or sell copies of the Software, and to permit persons to whom the
+//Software is furnished to do so, subject to the following conditions:
+//
+//The above copyright notice and this permission notice shall be included
+//in all copies or substantial portions of the Software.
+//
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+//OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+//THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+//IN THE SOFTWARE.
+
+#include "stdafx.h"
+#include "mhook-lib/mhook.h"
+
+//=========================================================================
+// Define _NtOpenProcess so we can dynamically bind to the function
+//
+typedef struct _CLIENT_ID {
+ DWORD_PTR UniqueProcess;
+ DWORD_PTR UniqueThread;
+} CLIENT_ID, *PCLIENT_ID;
+
+typedef ULONG (WINAPI* _NtOpenProcess)(OUT PHANDLE ProcessHandle,
+ IN ACCESS_MASK AccessMask, IN PVOID ObjectAttributes,
+ IN PCLIENT_ID ClientId );
+
+//=========================================================================
+// Define _SelectObject so we can dynamically bind to the function
+typedef HGDIOBJ (WINAPI* _SelectObject)(HDC hdc, HGDIOBJ hgdiobj);
+
+//=========================================================================
+// Define _getaddrinfo so we can dynamically bind to the function
+typedef int (WSAAPI* _getaddrinfo)(const char* nodename, const char* servname, const struct addrinfo* hints, struct addrinfo** res);
+
+//=========================================================================
+// Define _HeapAlloc so we can dynamically bind to the function
+typedef LPVOID (WINAPI *_HeapAlloc)(HANDLE, DWORD, SIZE_T);
+
+//=========================================================================
+// Define _NtClose so we can dynamically bind to the function
+typedef ULONG (WINAPI* _NtClose)(IN HANDLE Handle);
+
+//=========================================================================
+// Get the current (original) address to the functions to be hooked
+//
+_NtOpenProcess TrueNtOpenProcess = (_NtOpenProcess)
+ GetProcAddress(GetModuleHandle(L"ntdll"), "NtOpenProcess");
+
+_SelectObject TrueSelectObject = (_SelectObject)
+ GetProcAddress(GetModuleHandle(L"gdi32"), "SelectObject");
+
+_getaddrinfo Truegetaddrinfo = (_getaddrinfo)GetProcAddress(GetModuleHandle(L"ws2_32"), "getaddrinfo");
+
+_HeapAlloc TrueHeapAlloc = (_HeapAlloc)GetProcAddress(GetModuleHandle(L"kernel32"), "HeapAlloc");
+
+_NtClose TrueNtClose = (_NtClose)GetProcAddress(GetModuleHandle(L"ntdll"), "NtClose");
+
+//=========================================================================
+// This is the function that will replace NtOpenProcess once the hook
+// is in place
+//
+ULONG WINAPI HookNtOpenProcess(OUT PHANDLE ProcessHandle,
+ IN ACCESS_MASK AccessMask,
+ IN PVOID ObjectAttributes,
+ IN PCLIENT_ID ClientId)
+{
+ printf("***** Call to open process %d\n", ClientId->UniqueProcess);
+ return TrueNtOpenProcess(ProcessHandle, AccessMask,
+ ObjectAttributes, ClientId);
+}
+
+//=========================================================================
+// This is the function that will replace SelectObject once the hook
+// is in place
+//
+HGDIOBJ WINAPI HookSelectobject(HDC hdc, HGDIOBJ hgdiobj)
+{
+ printf("***** Call to SelectObject(0x%p, 0x%p)\n", hdc, hgdiobj);
+ return TrueSelectObject(hdc, hgdiobj);
+}
+
+//=========================================================================
+// This is the function that will replace SelectObject once the hook
+// is in place
+//
+int WSAAPI Hookgetaddrinfo(const char* nodename, const char* servname, const struct addrinfo* hints, struct addrinfo** res)
+{
+ printf("***** Call to getaddrinfo(0x%p, 0x%p, 0x%p, 0x%p)\n", nodename, servname, hints, res);
+ return Truegetaddrinfo(nodename, servname, hints, res);
+}
+
+//=========================================================================
+// This is the function that will replace HeapAlloc once the hook
+// is in place
+//
+LPVOID WINAPI HookHeapAlloc(HANDLE a_Handle, DWORD a_Bla, SIZE_T a_Bla2) {
+ printf("***** Call to HeapAlloc(0x%p, %u, 0x%p)\n", a_Handle, a_Bla, a_Bla2);
+ return TrueHeapAlloc(a_Handle, a_Bla, a_Bla2);
+}
+
+//=========================================================================
+// This is the function that will replace NtClose once the hook
+// is in place
+//
+ULONG WINAPI HookNtClose(HANDLE hHandle) {
+ printf("***** Call to NtClose(0x%p)\n", hHandle);
+ return TrueNtClose(hHandle);
+}
+
+//=========================================================================
+// This is where the work gets done.
+//
+int wmain(int argc, WCHAR* argv[])
+{
+ HANDLE hProc = NULL;
+
+ // Set the hook
+ if (Mhook_SetHook((PVOID*)&TrueNtOpenProcess, HookNtOpenProcess)) {
+ // Now call OpenProcess and observe NtOpenProcess being redirected
+ // under the hood.
+ hProc = OpenProcess(PROCESS_ALL_ACCESS,
+ FALSE, GetCurrentProcessId());
+ if (hProc) {
+ printf("Successfully opened self: %p\n", hProc);
+ CloseHandle(hProc);
+ } else {
+ printf("Could not open self: %d\n", GetLastError());
+ }
+ // Remove the hook
+ Mhook_Unhook((PVOID*)&TrueNtOpenProcess);
+ }
+
+ // Call OpenProces again - this time there won't be a redirection as
+ // the hook has bee removed.
+ hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
+ if (hProc) {
+ printf("Successfully opened self: %p\n", hProc);
+ CloseHandle(hProc);
+ } else {
+ printf("Could not open self: %d\n", GetLastError());
+ }
+
+ // Test another hook, this time in SelectObject
+ // (SelectObject is interesting in that on XP x64, the second instruction
+ // in the trampoline uses IP-relative addressing and we need to do some
+ // extra work under the hood to make things work properly. This really
+ // is more of a test case rather than a demo.)
+ printf("Testing SelectObject.\n");
+ if (Mhook_SetHook((PVOID*)&TrueSelectObject, HookSelectobject)) {
+ // error checking omitted for brevity. doesn't matter much
+ // in this context anyway.
+ HDC hdc = GetDC(NULL);
+ HDC hdcMem = CreateCompatibleDC(hdc);
+ HBITMAP hbm = CreateCompatibleBitmap(hdc, 32, 32);
+ HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbm);
+ SelectObject(hdcMem, hbmOld);
+ DeleteObject(hbm);
+ DeleteDC(hdcMem);
+ ReleaseDC(NULL, hdc);
+ // Remove the hook
+ Mhook_Unhook((PVOID*)&TrueSelectObject);
+ }
+
+ printf("Testing getaddrinfo.\n");
+ if (Mhook_SetHook((PVOID*)&Truegetaddrinfo, Hookgetaddrinfo)) {
+ // error checking omitted for brevity. doesn't matter much
+ // in this context anyway.
+ WSADATA wd = {0};
+ WSAStartup(MAKEWORD(2, 2), &wd);
+ char* ip = "localhost";
+ struct addrinfo aiHints;
+ struct addrinfo *res = NULL;
+ memset(&aiHints, 0, sizeof(aiHints));
+ aiHints.ai_family = PF_UNSPEC;
+ aiHints.ai_socktype = SOCK_STREAM;
+ if (getaddrinfo(ip, NULL, &aiHints, &res)) {
+ printf("getaddrinfo failed\n");
+ } else {
+ int n = 0;
+ while(res) {
+ res = res->ai_next;
+ n++;
+ }
+ printf("got %d addresses\n", n);
+ }
+ WSACleanup();
+ // Remove the hook
+ Mhook_Unhook((PVOID*)&Truegetaddrinfo);
+ }
+
+ printf("Testing HeapAlloc.\n");
+ if (Mhook_SetHook((PVOID*)&TrueHeapAlloc, HookHeapAlloc))
+ {
+ free(malloc(10));
+ // Remove the hook
+ Mhook_Unhook((PVOID*)&TrueHeapAlloc);
+ }
+
+ printf("Testing NtClose.\n");
+ if (Mhook_SetHook((PVOID*)&TrueNtClose, HookNtClose))
+ {
+ CloseHandle(NULL);
+ // Remove the hook
+ Mhook_Unhook((PVOID*)&TrueNtClose);
+ }
+
+ return 0;
+}
+