Improved API Dump and OBJ Track layers

Added generator script just for layers that generates API Dump and Object Tracker layers.  Improved output of API Dump layer.

5 files changed, 2833 insertions, 88 deletions

diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index cb75df66..be05b584 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -5,7 +5,9 @@ add_custom_command(OUTPUT generic_layer.c
 	           DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py
 	                   ${PROJECT_SOURCE_DIR}/xgl.py)
 
-set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I ../include")
+# TODO : With standard settings below we get warnings as error due to unused functions.
+#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I ../include")
+set (CMAKE_C_FLAGS "-std=c99 -Wextra -Wno-sign-compare -Wno-unused-parameter -I ../include")
 
 add_library (XGLLayerBasic SHARED basic_plugin.c)
 add_library (XGLLayerGeneric SHARED generic_layer.c)
diff --git a/layers/api_dump.c b/layers/api_dump.c
index 755d6dfd..4dffe3cb 100644
--- a/layers/api_dump.c
+++ b/layers/api_dump.c
@@ -30,6 +30,8 @@
 #include <assert.h>
 #include <pthread.h>
 #include "xglLayer.h"
+#include "xgl_string_helper.h"
+#include "xgl_struct_string_helper.h"
 
 static XGL_LAYER_DISPATCH_TABLE nextTable;
 static XGL_BASE_LAYER_OBJECT *pCurObj;
@@ -288,396 +290,400 @@ static void initLayerTable()
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    //printf("At start of layered GetGpuInfo\n");
     pCurObj = gpuw;
     pthread_once(&tabOnce, initLayerTable);
     XGL_RESULT result = nextTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
-    printf("xglGetGpuInfo(gpu = %p, infoType = %p, pDataSize = %i, pData = %p) = %s\n", (void*)gpu, (void*)infoType, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
-    //printf("Completed layered GetGpuInfo\n");
+    printf("xglGetGpuInfo(gpu = %p, infoType = %s, pDataSize = %i, pData = %p) = %s\n", (void*)gpu, string_XGL_PHYSICAL_GPU_INFO_TYPE(infoType), *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDevice(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice)
 {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    //printf("At start of layered CreateDevice\n");
     pCurObj = gpuw;
     pthread_once(&tabOnce, initLayerTable);
     XGL_RESULT result = nextTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
-    printf("xglCreateDevice(gpu = %p, pCreateInfo = %p, pDevice = %p) = %s\n", (void*)gpu, (void*)pCreateInfo, (void*)*pDevice, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
-    //printf("Completed layered CreateDevice\n");
+    printf("xglCreateDevice(gpu = %p, pCreateInfo = %p, pDevice = %p) = %s\n", (void*)gpu, (void*)pCreateInfo, (void*)*pDevice, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_device_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(XGL_DEVICE device)
 {
     XGL_RESULT result = nextTable.DestroyDevice(device);
-    printf("xglDestroyDevice(device = %p) = %s\n", (void*)device, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDestroyDevice(device = %p) = %s\n", (void*)device, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pExtName)
 {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    //printf("At start of layered GetExtensionSupport\n");
     pCurObj = gpuw;
     pthread_once(&tabOnce, initLayerTable);
     XGL_RESULT result = nextTable.GetExtensionSupport((XGL_PHYSICAL_GPU)gpuw->nextObject, pExtName);
-    printf("xglGetExtensionSupport(gpu = %p, pExtName = %p) = %s\n", (void*)gpu, (void*)pExtName, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
-    //printf("Completed layered GetExtensionSupport\n");
+    printf("xglGetExtensionSupport(gpu = %p, pExtName = %p) = %s\n", (void*)gpu, (void*)pExtName, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE * pOutLayerCount)
 {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    //printf("At start of layered EnumerateLayers\n");
     pCurObj = gpuw;
     pthread_once(&tabOnce, initLayerTable);
     XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayers, pOutLayerCount);
-    printf("xglEnumerateLayers(gpu = %p, maxLayerCount = %i, maxStringSize = %i, pOutLayers = %p, pOutLayerCount = %i) = %s\n", (void*)gpu, maxLayerCount, maxStringSize, (void*)pOutLayers, *pOutLayerCount, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
-    //printf("Completed layered EnumerateLayers\n");
+    printf("xglEnumerateLayers(gpu = %p, maxLayerCount = %i, maxStringSize = %i, pOutLayers = %p, pOutLayerCount = %i) = %s\n", (void*)gpu, maxLayerCount, maxStringSize, (void*)pOutLayers, *pOutLayerCount, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(XGL_DEVICE device, XGL_QUEUE_TYPE queueType, XGL_UINT queueIndex, XGL_QUEUE* pQueue)
 {
     XGL_RESULT result = nextTable.GetDeviceQueue(device, queueType, queueIndex, pQueue);
-    printf("xglGetDeviceQueue(device = %p, queueType = %p, queueIndex = %i, pQueue = %p) = %s\n", (void*)device, (void*)queueType, queueIndex, (void*)pQueue, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetDeviceQueue(device = %p, queueType = %s, queueIndex = %i, pQueue = %p) = %s\n", (void*)device, string_XGL_QUEUE_TYPE(queueType), queueIndex, (void*)pQueue, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI 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 result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, memRefCount, pMemRefs, fence);
-    printf("xglQueueSubmit(queue = %p, cmdBufferCount = %i, pCmdBuffers = %p, memRefCount = %i, pMemRefs = %p, fence = %p) = %s\n", (void*)queue, cmdBufferCount, (void*)pCmdBuffers, memRefCount, (void*)pMemRefs, (void*)fence, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglQueueSubmit(queue = %p, cmdBufferCount = %i, pCmdBuffers = %p, memRefCount = %i, pMemRefs = %p, fence = %p) = %s\n", (void*)queue, cmdBufferCount, (void*)pCmdBuffers, memRefCount, (void*)pMemRefs, (void*)fence, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(XGL_QUEUE queue, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs)
 {
     XGL_RESULT result = nextTable.QueueSetGlobalMemReferences(queue, memRefCount, pMemRefs);
-    printf("xglQueueSetGlobalMemReferences(queue = %p, memRefCount = %i, pMemRefs = %p) = %s\n", (void*)queue, memRefCount, (void*)pMemRefs, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglQueueSetGlobalMemReferences(queue = %p, memRefCount = %i, pMemRefs = %p) = %s\n", (void*)queue, memRefCount, (void*)pMemRefs, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(XGL_QUEUE queue)
 {
     XGL_RESULT result = nextTable.QueueWaitIdle(queue);
-    printf("xglQueueWaitIdle(queue = %p) = %s\n", (void*)queue, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglQueueWaitIdle(queue = %p) = %s\n", (void*)queue, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(XGL_DEVICE device)
 {
     XGL_RESULT result = nextTable.DeviceWaitIdle(device);
-    printf("xglDeviceWaitIdle(device = %p) = %s\n", (void*)device, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDeviceWaitIdle(device = %p) = %s\n", (void*)device, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMemoryHeapCount(XGL_DEVICE device, XGL_UINT* pCount)
 {
     XGL_RESULT result = nextTable.GetMemoryHeapCount(device, pCount);
-    printf("xglGetMemoryHeapCount(device = %p, pCount = %i) = %s\n", (void*)device, *pCount, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetMemoryHeapCount(device = %p, pCount = %i) = %s\n", (void*)device, *pCount, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMemoryHeapInfo(XGL_DEVICE device, XGL_UINT heapId, XGL_MEMORY_HEAP_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.GetMemoryHeapInfo(device, heapId, infoType, pDataSize, pData);
-    printf("xglGetMemoryHeapInfo(device = %p, heapId = %i, infoType = %p, pDataSize = %i, pData = %p) = %s\n", (void*)device, heapId, (void*)infoType, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetMemoryHeapInfo(device = %p, heapId = %i, infoType = %s, pDataSize = %i, pData = %p) = %s\n", (void*)device, heapId, string_XGL_MEMORY_HEAP_INFO_TYPE(infoType), *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglAllocMemory(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem)
 {
     XGL_RESULT result = nextTable.AllocMemory(device, pAllocInfo, pMem);
-    printf("xglAllocMemory(device = %p, pAllocInfo = %p, pMem = %p) = %s\n", (void*)device, (void*)pAllocInfo, (void*)pMem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglAllocMemory(device = %p, pAllocInfo = %p, pMem = %p) = %s\n", (void*)device, (void*)pAllocInfo, (void*)pMem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglFreeMemory(XGL_GPU_MEMORY mem)
 {
     XGL_RESULT result = nextTable.FreeMemory(mem);
-    printf("xglFreeMemory(mem = %p) = %s\n", (void*)mem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglFreeMemory(mem = %p) = %s\n", (void*)mem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority)
 {
     XGL_RESULT result = nextTable.SetMemoryPriority(mem, priority);
-    printf("xglSetMemoryPriority(mem = %p, priority = %p) = %s\n", (void*)mem, (void*)priority, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglSetMemoryPriority(mem = %p, priority = %p) = %s\n", (void*)mem, (void*)priority, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglMapMemory(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData)
 {
     XGL_RESULT result = nextTable.MapMemory(mem, flags, ppData);
-    printf("xglMapMemory(mem = %p, flags = %i, ppData = %p) = %s\n", (void*)mem, flags, (void*)ppData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglMapMemory(mem = %p, flags = %i, ppData = %p) = %s\n", (void*)mem, flags, (void*)ppData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(XGL_GPU_MEMORY mem)
 {
     XGL_RESULT result = nextTable.UnmapMemory(mem);
-    printf("xglUnmapMemory(mem = %p) = %s\n", (void*)mem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglUnmapMemory(mem = %p) = %s\n", (void*)mem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem)
 {
     XGL_RESULT result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
-    printf("xglPinSystemMemory(device = %p, pSysMem = %p, memSize = %i, pMem = %p) = %s\n", (void*)device, (void*)pSysMem, memSize, (void*)pMem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglPinSystemMemory(device = %p, pSysMem = %p, memSize = %i, pMem = %p) = %s\n", (void*)device, (void*)pSysMem, memSize, (void*)pMem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI 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)
 {
     XGL_RESULT result = nextTable.RemapVirtualMemoryPages(device, rangeCount, pRanges, preWaitSemaphoreCount, pPreWaitSemaphores, postSignalSemaphoreCount, pPostSignalSemaphores);
-    printf("xglRemapVirtualMemoryPages(device = %p, rangeCount = %i, pRanges = %p, preWaitSemaphoreCount = %i, pPreWaitSemaphores = %p, postSignalSemaphoreCount = %i, pPostSignalSemaphores = %p) = %s\n", (void*)device, rangeCount, (void*)pRanges, preWaitSemaphoreCount, (void*)pPreWaitSemaphores, postSignalSemaphoreCount, (void*)pPostSignalSemaphores, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglRemapVirtualMemoryPages(device = %p, rangeCount = %i, pRanges = %p, preWaitSemaphoreCount = %i, pPreWaitSemaphores = %p, postSignalSemaphoreCount = %i, pPostSignalSemaphores = %p) = %s\n", (void*)device, rangeCount, (void*)pRanges, preWaitSemaphoreCount, (void*)pPreWaitSemaphores, postSignalSemaphoreCount, (void*)pPostSignalSemaphores, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo)
 {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu0;
-    //printf("At start of layered GetMultiGpuCompatibility\n");
     pCurObj = gpuw;
     pthread_once(&tabOnce, initLayerTable);
     XGL_RESULT result = nextTable.GetMultiGpuCompatibility((XGL_PHYSICAL_GPU)gpuw->nextObject, gpu1, pInfo);
-    printf("xglGetMultiGpuCompatibility(gpu0 = %p, gpu1 = %p, pInfo = %p) = %s\n", (void*)gpu0, (void*)gpu1, (void*)pInfo, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
-    //printf("Completed layered GetMultiGpuCompatibility\n");
+    printf("xglGetMultiGpuCompatibility(gpu0 = %p, gpu1 = %p, pInfo = %p) = %s\n", (void*)gpu0, (void*)gpu1, (void*)pInfo, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
 {
     XGL_RESULT result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
-    printf("xglOpenSharedMemory(device = %p, pOpenInfo = %p, pMem = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pMem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglOpenSharedMemory(device = %p, pOpenInfo = %p, pMem = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pMem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore)
 {
     XGL_RESULT result = nextTable.OpenSharedQueueSemaphore(device, pOpenInfo, pSemaphore);
-    printf("xglOpenSharedQueueSemaphore(device = %p, pOpenInfo = %p, pSemaphore = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pSemaphore, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglOpenSharedQueueSemaphore(device = %p, pOpenInfo = %p, pSemaphore = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pSemaphore, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem)
 {
     XGL_RESULT result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
-    printf("xglOpenPeerMemory(device = %p, pOpenInfo = %p, pMem = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pMem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglOpenPeerMemory(device = %p, pOpenInfo = %p, pMem = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pMem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
 {
     XGL_RESULT result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
-    printf("xglOpenPeerImage(device = %p, pOpenInfo = %p, pImage = %p, pMem = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pImage, (void*)pMem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglOpenPeerImage(device = %p, pOpenInfo = %p, pImage = %p, pMem = %p) = %s\n", (void*)device, (void*)pOpenInfo, (void*)pImage, (void*)pMem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDestroyObject(XGL_OBJECT object)
 {
     XGL_RESULT result = nextTable.DestroyObject(object);
-    printf("xglDestroyObject(object = %p) = %s\n", (void*)object, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDestroyObject(object = %p) = %s\n", (void*)object, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.GetObjectInfo(object, infoType, pDataSize, pData);
-    printf("xglGetObjectInfo(object = %p, infoType = %p, pDataSize = %i, pData = %p) = %s\n", (void*)object, (void*)infoType, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetObjectInfo(object = %p, infoType = %s, pDataSize = %i, pData = %p) = %s\n", (void*)object, string_XGL_OBJECT_INFO_TYPE(infoType), *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset)
 {
     XGL_RESULT result = nextTable.BindObjectMemory(object, mem, offset);
-    printf("xglBindObjectMemory(object = %p, mem = %p, offset = %i) = %s\n", (void*)object, (void*)mem, offset, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglBindObjectMemory(object = %p, mem = %p, offset = %i) = %s\n", (void*)object, (void*)mem, offset, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateFence(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence)
 {
     XGL_RESULT result = nextTable.CreateFence(device, pCreateInfo, pFence);
-    printf("xglCreateFence(device = %p, pCreateInfo = %p, pFence = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pFence, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateFence(device = %p, pCreateInfo = %p, pFence = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pFence, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_fence_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(XGL_FENCE fence)
 {
     XGL_RESULT result = nextTable.GetFenceStatus(fence);
-    printf("xglGetFenceStatus(fence = %p) = %s\n", (void*)fence, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetFenceStatus(fence = %p) = %s\n", (void*)fence, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitForFences(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout)
 {
     XGL_RESULT result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
-    printf("xglWaitForFences(device = %p, fenceCount = %i, pFences = %p, waitAll = %u, timeout = %lu) = %s\n", (void*)device, fenceCount, (void*)pFences, waitAll, timeout, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglWaitForFences(device = %p, fenceCount = %i, pFences = %p, waitAll = %u, timeout = %lu) = %s\n", (void*)device, fenceCount, (void*)pFences, waitAll, timeout, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueueSemaphore(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore)
 {
     XGL_RESULT result = nextTable.CreateQueueSemaphore(device, pCreateInfo, pSemaphore);
-    printf("xglCreateQueueSemaphore(device = %p, pCreateInfo = %p, pSemaphore = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pSemaphore, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateQueueSemaphore(device = %p, pCreateInfo = %p, pSemaphore = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pSemaphore, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_queue_semaphore_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSignalQueueSemaphore(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore)
 {
     XGL_RESULT result = nextTable.SignalQueueSemaphore(queue, semaphore);
-    printf("xglSignalQueueSemaphore(queue = %p, semaphore = %p) = %s\n", (void*)queue, (void*)semaphore, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglSignalQueueSemaphore(queue = %p, semaphore = %p) = %s\n", (void*)queue, (void*)semaphore, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWaitQueueSemaphore(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore)
 {
     XGL_RESULT result = nextTable.WaitQueueSemaphore(queue, semaphore);
-    printf("xglWaitQueueSemaphore(queue = %p, semaphore = %p) = %s\n", (void*)queue, (void*)semaphore, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglWaitQueueSemaphore(queue = %p, semaphore = %p) = %s\n", (void*)queue, (void*)semaphore, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateEvent(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent)
 {
     XGL_RESULT result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
-    printf("xglCreateEvent(device = %p, pCreateInfo = %p, pEvent = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pEvent, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateEvent(device = %p, pCreateInfo = %p, pEvent = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pEvent, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_event_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(XGL_EVENT event)
 {
     XGL_RESULT result = nextTable.GetEventStatus(event);
-    printf("xglGetEventStatus(event = %p) = %s\n", (void*)event, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetEventStatus(event = %p) = %s\n", (void*)event, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglSetEvent(XGL_EVENT event)
 {
     XGL_RESULT result = nextTable.SetEvent(event);
-    printf("xglSetEvent(event = %p) = %s\n", (void*)event, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglSetEvent(event = %p) = %s\n", (void*)event, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetEvent(XGL_EVENT event)
 {
     XGL_RESULT result = nextTable.ResetEvent(event);
-    printf("xglResetEvent(event = %p) = %s\n", (void*)event, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglResetEvent(event = %p) = %s\n", (void*)event, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool)
 {
     XGL_RESULT result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
-    printf("xglCreateQueryPool(device = %p, pCreateInfo = %p, pQueryPool = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pQueryPool, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateQueryPool(device = %p, pCreateInfo = %p, pQueryPool = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pQueryPool, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_query_pool_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.GetQueryPoolResults(queryPool, startQuery, queryCount, pDataSize, pData);
-    printf("xglGetQueryPoolResults(queryPool = %p, startQuery = %i, queryCount = %i, pDataSize = %i, pData = %p) = %s\n", (void*)queryPool, startQuery, queryCount, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetQueryPoolResults(queryPool = %p, startQuery = %i, queryCount = %i, pDataSize = %i, pData = %p) = %s\n", (void*)queryPool, startQuery, queryCount, *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
-    printf("xglGetFormatInfo(device = %p, format.channelFormat = %i, format.numericFormat = %i, infoType = %i, pDataSize = %i, pData = %p) = %s\n", (void*)device, format.channelFormat, format.numericFormat, infoType, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetFormatInfo(device = %p, format.channelFormat = %s, format.numericFormat = %s, infoType = %i, pDataSize = %i, pData = %p) = %s\n", (void*)device, string_XGL_CHANNEL_FORMAT(format.channelFormat), string_XGL_NUM_FORMAT(format.numericFormat), infoType, *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImage(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage)
 {
     XGL_RESULT result = nextTable.CreateImage(device, pCreateInfo, pImage);
-    printf("xglCreateImage(device = %p, pCreateInfo = %p, pImage = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pImage, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateImage(device = %p, pCreateInfo = %p, pImage = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pImage, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_image_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.GetImageSubresourceInfo(image, pSubresource, infoType, pDataSize, pData);
-    printf("xglGetImageSubresourceInfo(image = %p, pSubresource = %p, infoType = %p, pDataSize = %i, pData = %p) = %s\n", (void*)image, (void*)pSubresource, (void*)infoType, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglGetImageSubresourceInfo(image = %p, pSubresource = %p, infoType = %s, pDataSize = %i, pData = %p) = %s\n", (void*)image, (void*)pSubresource, string_XGL_SUBRESOURCE_INFO_TYPE(infoType), *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateImageView(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView)
 {
     XGL_RESULT result = nextTable.CreateImageView(device, pCreateInfo, pView);
-    printf("xglCreateImageView(device = %p, pCreateInfo = %p, pView = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pView, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateImageView(device = %p, pCreateInfo = %p, pView = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pView, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_image_view_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView)
 {
     XGL_RESULT result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
-    printf("xglCreateColorAttachmentView(device = %p, pCreateInfo = %p, pView = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pView, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateColorAttachmentView(device = %p, pCreateInfo = %p, pView = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pView, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_color_attachment_view_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView)
 {
     XGL_RESULT result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
-    printf("xglCreateDepthStencilView(device = %p, pCreateInfo = %p, pView = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pView, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateDepthStencilView(device = %p, pCreateInfo = %p, pView = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pView, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_depth_stencil_view_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateShader(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader)
 {
     XGL_RESULT result = nextTable.CreateShader(device, pCreateInfo, pShader);
-    printf("xglCreateShader(device = %p, pCreateInfo = %p, pShader = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pShader, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateShader(device = %p, pCreateInfo = %p, pShader = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pShader, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_shader_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
 {
     XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
-    printf("xglCreateGraphicsPipeline(device = %p, pCreateInfo = %p, pPipeline = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pPipeline, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateGraphicsPipeline(device = %p, pCreateInfo = %p, pPipeline = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pPipeline, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_graphics_pipeline_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
 {
     XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
-    printf("xglCreateComputePipeline(device = %p, pCreateInfo = %p, pPipeline = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pPipeline, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateComputePipeline(device = %p, pCreateInfo = %p, pPipeline = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pPipeline, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_compute_pipeline_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglStorePipeline(XGL_PIPELINE pipeline, XGL_SIZE* pDataSize, XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.StorePipeline(pipeline, pDataSize, pData);
-    printf("xglStorePipeline(pipeline = %p, pDataSize = %i, pData = %p) = %s\n", (void*)pipeline, *pDataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglStorePipeline(pipeline = %p, pDataSize = %i, pData = %p) = %s\n", (void*)pipeline, *pDataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(XGL_DEVICE device, XGL_SIZE dataSize, const XGL_VOID* pData, XGL_PIPELINE* pPipeline)
 {
     XGL_RESULT result = nextTable.LoadPipeline(device, dataSize, pData, pPipeline);
-    printf("xglLoadPipeline(device = %p, dataSize = %i, pData = %p, pPipeline = %p) = %s\n", (void*)device, dataSize, (void*)pData, (void*)pPipeline, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglLoadPipeline(device = %p, dataSize = %i, pData = %p, pPipeline = %p) = %s\n", (void*)device, dataSize, (void*)pData, (void*)pPipeline, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta)
 {
     XGL_RESULT result = nextTable.CreatePipelineDelta(device, p1, p2, delta);
-    printf("xglCreatePipelineDelta(device = %p, p1 = %p, p2 = %p, delta = %p) = %s\n", (void*)device, (void*)p1, (void*)p2, (void*)*delta, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreatePipelineDelta(device = %p, p1 = %p, p2 = %p, delta = %p) = %s\n", (void*)device, (void*)p1, (void*)p2, (void*)*delta, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateSampler(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler)
 {
     XGL_RESULT result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
-    printf("xglCreateSampler(device = %p, pCreateInfo = %p, pSampler = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pSampler, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateSampler(device = %p, pCreateInfo = %p, pSampler = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pSampler, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_sampler_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSet(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET* pDescriptorSet)
 {
     XGL_RESULT result = nextTable.CreateDescriptorSet(device, pCreateInfo, pDescriptorSet);
-    printf("xglCreateDescriptorSet(device = %p, pCreateInfo = %p, pDescriptorSet = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pDescriptorSet, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateDescriptorSet(device = %p, pCreateInfo = %p, pDescriptorSet = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pDescriptorSet, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_descriptor_set_create_info(pCreateInfo, "    "));
     return result;
 }
 
@@ -726,63 +732,69 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglClearDescriptorSetSlots(XGL_DESCRIPTOR_SET d
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateViewportState(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState)
 {
     XGL_RESULT result = nextTable.CreateViewportState(device, pCreateInfo, pState);
-    printf("xglCreateViewportState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateViewportState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_viewport_state_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateRasterState(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState)
 {
     XGL_RESULT result = nextTable.CreateRasterState(device, pCreateInfo, pState);
-    printf("xglCreateRasterState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateRasterState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_raster_state_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateMsaaState(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState)
 {
     XGL_RESULT result = nextTable.CreateMsaaState(device, pCreateInfo, pState);
-    printf("xglCreateMsaaState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateMsaaState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_msaa_state_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateColorBlendState(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState)
 {
     XGL_RESULT result = nextTable.CreateColorBlendState(device, pCreateInfo, pState);
-    printf("xglCreateColorBlendState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateColorBlendState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_color_blend_state_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilState(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState)
 {
     XGL_RESULT result = nextTable.CreateDepthStencilState(device, pCreateInfo, pState);
-    printf("xglCreateDepthStencilState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateDepthStencilState(device = %p, pCreateInfo = %p, pState = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pState, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_depth_stencil_state_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer)
 {
     XGL_RESULT result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
-    printf("xglCreateCommandBuffer(device = %p, pCreateInfo = %p, pCmdBuffer = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pCmdBuffer, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglCreateCommandBuffer(device = %p, pCreateInfo = %p, pCmdBuffer = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)*pCmdBuffer, string_XGL_RESULT(result));
+    printf("   pCreateInfo (%p)\n%s\n", (void*)pCreateInfo, xgl_print_xgl_cmd_buffer_create_info(pCreateInfo, "    "));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_FLAGS flags)
 {
     XGL_RESULT result = nextTable.BeginCommandBuffer(cmdBuffer, flags);
-    printf("xglBeginCommandBuffer(cmdBuffer = %p, flags = %i) = %s\n", (void*)cmdBuffer, flags, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglBeginCommandBuffer(cmdBuffer = %p, flags = %i) = %s\n", (void*)cmdBuffer, flags, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
 {
     XGL_RESULT result = nextTable.EndCommandBuffer(cmdBuffer);
-    printf("xglEndCommandBuffer(cmdBuffer = %p) = %s\n", (void*)cmdBuffer, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglEndCommandBuffer(cmdBuffer = %p) = %s\n", (void*)cmdBuffer, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(XGL_CMD_BUFFER cmdBuffer)
 {
     XGL_RESULT result = nextTable.ResetCommandBuffer(cmdBuffer);
-    printf("xglResetCommandBuffer(cmdBuffer = %p) = %s\n", (void*)cmdBuffer, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglResetCommandBuffer(cmdBuffer = %p) = %s\n", (void*)cmdBuffer, string_XGL_RESULT(result));
     return result;
 }
 
@@ -819,7 +831,7 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(XGL_CMD_BUFFER cmdB
 XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindIndexData(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType)
 {
     nextTable.CmdBindIndexData(cmdBuffer, mem, offset, indexType);
-    printf("xglCmdBindIndexData(cmdBuffer = %p, mem = %p, offset = %i, indexType = %p)\n", (void*)cmdBuffer, (void*)mem, offset, (void*)indexType);
+    printf("xglCmdBindIndexData(cmdBuffer = %p, mem = %p, offset = %i, indexType = %s)\n", (void*)cmdBuffer, (void*)mem, offset, string_XGL_INDEX_TYPE(indexType));
 }
 
 XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdBindAttachments(XGL_CMD_BUFFER cmdBuffer, XGL_UINT colorAttachmentCount, const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments, const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment)
@@ -981,7 +993,7 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer,
 XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdWriteTimestamp(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset)
 {
     nextTable.CmdWriteTimestamp(cmdBuffer, timestampType, destMem, destOffset);
-    printf("xglCmdWriteTimestamp(cmdBuffer = %p, timestampType = %p, destMem = %p, destOffset = %i)\n", (void*)cmdBuffer, (void*)timestampType, (void*)destMem, destOffset);
+    printf("xglCmdWriteTimestamp(cmdBuffer = %p, timestampType = %s, destMem = %p, destOffset = %i)\n", (void*)cmdBuffer, string_XGL_TIMESTAMP_TYPE(timestampType), (void*)destMem, destOffset);
 }
 
 XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdInitAtomicCounters(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData)
@@ -1005,49 +1017,49 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSaveAtomicCounters(XGL_CMD_BUFFER cmdBuff
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel)
 {
     XGL_RESULT result = nextTable.DbgSetValidationLevel(device, validationLevel);
-    printf("xglDbgSetValidationLevel(device = %p, validationLevel = %p) = %s\n", (void*)device, (void*)validationLevel, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgSetValidationLevel(device = %p, validationLevel = %p) = %s\n", (void*)device, (void*)validationLevel, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, XGL_VOID* pUserData)
 {
     XGL_RESULT result = nextTable.DbgRegisterMsgCallback(pfnMsgCallback, pUserData);
-    printf("xglDbgRegisterMsgCallback(pfnMsgCallback = %p, pUserData = %p) = %s\n", (void*)pfnMsgCallback, (void*)pUserData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgRegisterMsgCallback(pfnMsgCallback = %p, pUserData = %p) = %s\n", (void*)pfnMsgCallback, (void*)pUserData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
 {
     XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback);
-    printf("xglDbgUnregisterMsgCallback(pfnMsgCallback = %p) = %s\n", (void*)pfnMsgCallback, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgUnregisterMsgCallback(pfnMsgCallback = %p) = %s\n", (void*)pfnMsgCallback, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(XGL_DEVICE device, XGL_INT msgCode, XGL_DBG_MSG_FILTER filter)
 {
     XGL_RESULT result = nextTable.DbgSetMessageFilter(device, msgCode, filter);
-    printf("xglDbgSetMessageFilter(device = %p, msgCode = %i, filter = %p) = %s\n", (void*)device, msgCode, (void*)filter, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgSetMessageFilter(device = %p, msgCode = %i, filter = %p) = %s\n", (void*)device, msgCode, (void*)filter, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(XGL_BASE_OBJECT object, XGL_SIZE tagSize, const XGL_VOID* pTag)
 {
     XGL_RESULT result = nextTable.DbgSetObjectTag(object, tagSize, pTag);
-    printf("xglDbgSetObjectTag(object = %p, tagSize = %i, pTag = %p) = %s\n", (void*)object, tagSize, (void*)pTag, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgSetObjectTag(object = %p, tagSize = %i, pTag = %p) = %s\n", (void*)object, tagSize, (void*)pTag, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_DBG_GLOBAL_OPTION dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.DbgSetGlobalOption(dbgOption, dataSize, pData);
-    printf("xglDbgSetGlobalOption(dbgOption = %p, dataSize = %i, pData = %p) = %s\n", (void*)dbgOption, dataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgSetGlobalOption(dbgOption = %p, dataSize = %i, pData = %p) = %s\n", (void*)dbgOption, dataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData)
 {
     XGL_RESULT result = nextTable.DbgSetDeviceOption(device, dbgOption, dataSize, pData);
-    printf("xglDbgSetDeviceOption(device = %p, dbgOption = %p, dataSize = %i, pData = %p) = %s\n", (void*)device, (void*)dbgOption, dataSize, (void*)pData, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglDbgSetDeviceOption(device = %p, dbgOption = %p, dataSize = %i, pData = %p) = %s\n", (void*)device, (void*)dbgOption, dataSize, (void*)pData, string_XGL_RESULT(result));
     return result;
 }
 
@@ -1066,33 +1078,31 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdDbgMarkerEnd(XGL_CMD_BUFFER cmdBuffer)
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11AssociateConnection(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo)
 {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
-    //printf("At start of layered WsiX11AssociateConnection\n");
     pCurObj = gpuw;
     pthread_once(&tabOnce, initLayerTable);
     XGL_RESULT result = nextTable.WsiX11AssociateConnection((XGL_PHYSICAL_GPU)gpuw->nextObject, pConnectionInfo);
-    printf("xglWsiX11AssociateConnection(gpu = %p, pConnectionInfo = %p) = %s\n", (void*)gpu, (void*)pConnectionInfo, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
-    //printf("Completed layered WsiX11AssociateConnection\n");
+    printf("xglWsiX11AssociateConnection(gpu = %p, pConnectionInfo = %p) = %s\n", (void*)gpu, (void*)pConnectionInfo, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11GetMSC(XGL_DEVICE device, xcb_randr_crtc_t crtc, XGL_UINT64* pMsc)
 {
     XGL_RESULT result = nextTable.WsiX11GetMSC(device, crtc, pMsc);
-    printf("xglWsiX11GetMSC(device = %p, crtc = %i, pMsc = %lu) = %s\n", (void*)device, crtc, *pMsc, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglWsiX11GetMSC(device = %p, crtc = %i, pMsc = %lu) = %s\n", (void*)device, crtc, *pMsc, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11CreatePresentableImage(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem)
 {
     XGL_RESULT result = nextTable.WsiX11CreatePresentableImage(device, pCreateInfo, pImage, pMem);
-    printf("xglWsiX11CreatePresentableImage(device = %p, pCreateInfo = %p, pImage = %p, pMem = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)pImage, (void*)pMem, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglWsiX11CreatePresentableImage(device = %p, pCreateInfo = %p, pImage = %p, pMem = %p) = %s\n", (void*)device, (void*)pCreateInfo, (void*)pImage, (void*)pMem, string_XGL_RESULT(result));
     return result;
 }
 
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglWsiX11QueuePresent(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence)
 {
     XGL_RESULT result = nextTable.WsiX11QueuePresent(queue, pPresentInfo, fence);
-    printf("xglWsiX11QueuePresent(queue = %p, pPresentInfo = %p, fence = %p) = %s\n", (void*)queue, (void*)pPresentInfo, (void*)fence, (result == XGL_SUCCESS) ? "XGL_SUCCESS" : "XGL_FAIL");
+    printf("xglWsiX11QueuePresent(queue = %p, pPresentInfo = %p, fence = %p) = %s\n", (void*)queue, (void*)pPresentInfo, (void*)fence, string_XGL_RESULT(result));
     return result;
 }
 
diff --git a/layers/xgl_string_helper.h b/layers/xgl_string_helper.h
new file mode 100644
index 00000000..b5941ec4
--- /dev/null
+++ b/layers/xgl_string_helper.h
@@ -0,0 +1,1737 @@
+#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";
+
+    default:
+        return "Unhandled XGL_MEMORY_PRIORITY";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_ASPECT";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_NUM_FORMAT";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_TEX_FILTER";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_DESCRIPTOR_SET_SLOT_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_TEX_ADDRESS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_QUERY_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_ATOMIC_OP";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_MEMORY_HEAP_INFO_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_BLEND_FUNC";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_MEMORY_STATE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_FORMAT_INFO_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_STATE_BIND_POINT";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_MEMORY_REF_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_TIMESTAMP_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_MEMORY_HEAP_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_MEMORY_ALLOC_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_BORDER_COLOR_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_STATE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_TEX_MIPMAP_MODE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_LOGIC_OP";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_VALIDATION_LEVEL";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_CULL_MODE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_CHANNEL_SWIZZLE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_RESULT";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_STRUCTURE_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_FILL_MODE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_VIEW_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_INDEX_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_QUEUE_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_STENCIL_OP";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_CHANNEL_FORMAT";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_COMPARE_FUNC";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_HEAP_MEMORY_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_OBJECT_INFO_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_IMAGE_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";
+
+    default:
+        return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_FACE_ORIENTATION";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_QUEUE_FLAGS";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_PIPELINE_BIND_POINT";
+    }
+    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";
+
+    default:
+        return "Unhandled XGL_BLEND";
+    }
+    return "Unhandled XGL_BLEND";
+}
+
diff --git a/layers/xgl_struct_string_helper.h b/layers/xgl_struct_string_helper.h
new file mode 100644
index 00000000..7396e534
--- /dev/null
+++ b/layers/xgl_struct_string_helper.h
@@ -0,0 +1,554 @@
+//This is the copyright
+//#includes, #defines, globals and such...
+#include <xgl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "xgl_string_helper.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/xgl-layer-generate.py b/xgl-layer-generate.py
new file mode 100755
index 00000000..65183a32
--- /dev/null
+++ b/xgl-layer-generate.py
@@ -0,0 +1,442 @@
+#!/usr/bin/env python3
+#
+# XGL
+#
+# Copyright (C) 2014 LunarG, Inc.
+#
+# 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.
+#
+# Authors:
+#   Chia-I Wu <olv@lunarg.com>
+
+import sys
+
+import xgl
+
+class Subcommand(object):
+    def __init__(self, argv):
+        self.argv = argv
+        self.protos = ()
+        self.headers = ()
+
+    def run(self):
+        self.protos = xgl.core + xgl.ext_wsi_x11
+        self.headers = xgl.core_headers + xgl.ext_wsi_x11_headers
+        print(self.generate())
+
+    def generate(self):
+        copyright = self.generate_copyright()
+        header = self.generate_header()
+        body = self.generate_body()
+        footer = self.generate_footer()
+
+        contents = []
+        if copyright:
+            contents.append(copyright)
+        if header:
+            contents.append(header)
+        if body:
+            contents.append(body)
+        if footer:
+            contents.append(footer)
+
+        return "\n\n".join(contents)
+
+    def generate_copyright(self):
+        return """/* THIS FILE IS GENERATED.  DO NOT EDIT. */
+
+/*
+ * XGL
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * 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.
+ */"""
+
+    def generate_header(self):
+        return "\n".join(["#include <" + h + ">" for h in self.headers])
+
+    def generate_body(self):
+        pass
+
+    def generate_footer(self):
+        pass
+
+    # Return set of printf '%' qualifier and input to that qualifier
+    def _get_printf_params(self, xgl_type, name, last_create):
+        # TODO : Need ENUM and STRUCT checks here
+        if "_TYPE" in xgl_type: # TODO : This should be generic ENUM check
+            return ("%s", "string_%s(%s)" % (xgl_type.strip('const ').strip('*'), name))
+        if "XGL_CHAR*" == xgl_type:
+            return ("%s", name)
+        if "UINT64" in xgl_type:
+            if '*' in xgl_type:
+                return ("%lu", "*%s" % name)
+            return ("%lu", name)
+        if "FLOAT" in xgl_type:
+            if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
+                return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
+            return ("%f", name)
+        if "BOOL" in xgl_type:
+            return ("%u", name)
+        if True in [t in xgl_type for t in ["INT", "SIZE", "FLAGS", "MASK"]]:
+            if '[' in xgl_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
+                return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
+            if '*' in xgl_type:
+                return ("%i", "*%s" % name)
+            return ("%i", name)
+        if last_create:
+            return ("%p", "(void*)*%s" % name)
+        return ("%p", "(void*)%s" % name)
+
+    def _generate_icd_dispatch_table(self):
+        proto_map = {}
+        for proto in self.protos:
+            proto_map[proto.name] = proto
+
+        entries = []
+        for name in xgl.icd_dispatch_table:
+            proto = proto_map[name]
+            entries.append(proto.c_typedef(attr="XGLAPI"))
+
+        return """struct icd_dispatch_table {
+    %s;
+};""" % ";\n    ".join(entries)
+
+    def _generate_dispatch_entrypoints(self, qual="", layer="generic"):
+        if qual:
+            qual += " "
+
+        funcs = []
+        for proto in self.protos:
+            if proto.name != "GetProcAddr" and proto.name != "InitAndEnumerateGpus":
+                if "generic" == layer:
+                    decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+                    param0_name = proto.params[0].name
+                    ret_val = ''
+                    stmt = ''
+                    if proto.ret != "XGL_VOID":
+                        ret_val = "XGL_RESULT result = "
+                        stmt = "    return result;\n"
+                    if proto.params[0].ty != "XGL_PHYSICAL_GPU":
+                        funcs.append('%s%s\n'
+                                 '{\n'
+                                 '    %snextTable.%s;\n'
+                                 '%s'
+                                 '}' % (qual, decl, ret_val, proto.c_call(), stmt))
+                    else:
+                        c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+                        funcs.append('%s%s\n'
+                                 '{\n'
+                                 '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                                 '    printf("At start of layered %s\\n");\n'
+                                 '    pCurObj = gpuw;\n'
+                                 '    pthread_once(&tabOnce, initLayerTable);\n'
+                                 '    %snextTable.%s;\n'
+                                 '    printf("Completed layered %s\\n");\n'
+                                 '%s'
+                                 '}' % (qual, decl, proto.params[0].name, proto.name, ret_val, c_call, proto.name, stmt))
+                elif "apidump" == layer:
+                    decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+                    param0_name = proto.params[0].name
+                    ret_val = ''
+                    stmt = ''
+                    cis_param_index = -1 # Store index when func has pCreateInfo param
+                    create_func = False
+                    if 'Create' in proto.name:
+                        create_func = True
+                    if proto.ret != "XGL_VOID":
+                        ret_val = "XGL_RESULT result = "
+                        stmt = "    return result;\n"
+                    log_func = 'printf("xgl%s(' % proto.name
+                    print_vals = ''
+                    pindex = 0
+                    for p in proto.params:
+                        if p.name == proto.params[-1].name and create_func: # last param of create func
+                            (pft, pfi) = self._get_printf_params(p.ty, p.name, True)
+                        else:
+                            (pft, pfi) = self._get_printf_params(p.ty, p.name, False)
+                        log_func += '%s = %s, ' % (p.name, pft)
+                        print_vals += ', %s' % (pfi)
+                        if "pCreateInfo" in p.name:
+                            cis_param_index = pindex
+                        pindex += 1
+                    log_func = log_func.strip(', ')
+                    if proto.ret != "XGL_VOID":
+                        log_func += ') = %s\\n"'
+                        print_vals += ', string_XGL_RESULT(result)' 
+                    else:
+                        log_func += ')\\n"'
+                    log_func = '%s%s);' % (log_func, print_vals)
+                    if cis_param_index >= 0:
+                        cis_print_func = 'xgl_print_%s' % (proto.params[cis_param_index].ty.strip('const ').strip('*').lower())
+                        log_func += '\n    printf("   pCreateInfo (%%p)\\n%%s\\n", (void*)pCreateInfo, %s(pCreateInfo, "    "));' % (cis_print_func)
+                    if proto.params[0].ty != "XGL_PHYSICAL_GPU":
+                        funcs.append('%s%s\n'
+                                 '{\n'
+                                 '    %snextTable.%s;\n'
+                                 '    %s\n'
+                                 '%s'
+                                 '}' % (qual, decl, ret_val, proto.c_call(), log_func, stmt))
+                    else:
+                        c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+                        funcs.append('%s%s\n'
+                                 '{\n'
+                                 '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                                 '    pCurObj = gpuw;\n'
+                                 '    pthread_once(&tabOnce, initLayerTable);\n'
+                                 '    %snextTable.%s;\n'
+                                 '    %s\n'
+                                 '%s'
+                                 '}' % (qual, decl, proto.params[0].name, ret_val, c_call, log_func, stmt))
+                elif "objecttracker" == layer:
+                    decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+                    param0_name = proto.params[0].name
+                    create_line = ''
+                    destroy_line = ''
+                    using_line = '    ll_increment_use_count((XGL_VOID*)%s);\n    printf("OBJ[%%llu] : USING %s object %%p (%%lu total uses)\\n", object_track_index++, (void*)%s, ll_get_obj_uses((XGL_VOID*)%s));\n' % (param0_name, param0_name, param0_name, param0_name)
+                    if 'Create' in proto.name:
+                        create_line = '    printf("OBJ[%%llu] : CREATE %s object %%p\\n", object_track_index++, (void*)*%s);\n    ll_insert_obj((XGL_VOID*)*%s, "%s");\n' % (proto.params[-1].ty.strip('*'), proto.params[-1].name, proto.params[-1].name, proto.params[-1].ty.strip('*'))
+                    if 'Destroy' in proto.name:
+                        destroy_line = '    printf("OBJ[%%llu] : DESTROY %s object %%p\\n", object_track_index++, (void*)%s);\n    ll_remove_obj((XGL_VOID*)%s);\n' % (param0_name, param0_name, param0_name)
+                        using_line = ''
+                    ret_val = ''
+                    stmt = ''
+                    if proto.ret != "XGL_VOID":
+                        ret_val = "XGL_RESULT result = "
+                        stmt = "    return result;\n"
+                    if proto.params[0].ty != "XGL_PHYSICAL_GPU":
+                        funcs.append('%s%s\n'
+                                 '{\n'
+                                 '%s'
+                                 '    %snextTable.%s;\n'
+                                 '%s%s'
+                                 '%s'
+                                 '}' % (qual, decl, using_line, ret_val, proto.c_call(), create_line, destroy_line, stmt))
+                    else:
+                        c_call = proto.c_call().replace("(" + proto.params[0].name, "((XGL_PHYSICAL_GPU)gpuw->nextObject", 1)
+                        funcs.append('%s%s\n'
+                                 '{\n'
+                                 '    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) %s;\n'
+                                 '%s'
+                                 '    pCurObj = gpuw;\n'
+                                 '    pthread_once(&tabOnce, initLayerTable);\n'
+                                 '    %snextTable.%s;\n'
+                                 '%s%s'
+                                 '%s'
+                                 '}' % (qual, decl, proto.params[0].name, using_line, ret_val, c_call, create_line, destroy_line, stmt))
+
+        # TODO : Put this code somewhere so it gets called at the end if objects not deleted :
+        #     // Report any remaining objects in LL
+        #     objNode *pTrav = pObjLLHead;
+        #     while (pTrav) {
+        #         printf("WARN : %s object %p has not been destroyed.\n", pTrav->objType, pTrav->pObj);
+        #    }
+
+        return "\n\n".join(funcs)
+
+    def _generate_layer_gpa_function(self, prefix="xgl"):
+        func_body = []
+        func_body.append("XGL_LAYER_EXPORT XGL_VOID* XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* funcName)\n"
+                         "{\n"
+                         "    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;\n"
+                         "    if (gpu == NULL)\n"
+                         "        return NULL;\n"
+                         "    pCurObj = gpuw;\n"
+                         "    pthread_once(&tabOnce, initLayerTable);\n\n"
+                         '    if (!strncmp("xglGetProcAddr", (const char *) funcName, sizeof("xglGetProcAddr")))\n'
+                         '        return xglGetProcAddr;')
+        for name in xgl.icd_dispatch_table:
+            if name == "GetProcAddr":
+                continue
+            if name == "InitAndEnumerateGpus":
+                func_body.append('    else if (!strncmp("%s%s", (const char *) funcName, sizeof("%s%s")))\n'
+                             '        return nextTable.%s;' % (prefix, name, prefix, name, name))
+            else:
+                func_body.append('    else if (!strncmp("%s%s", (const char *) funcName, sizeof("%s%s")))\n'
+                             '        return %s%s;' % (prefix, name, prefix, name, prefix, name))
+
+        func_body.append("    else {\n"
+                         "        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;\n"
+                         "        if (gpuw->pGPA == NULL)\n"
+                         "            return NULL;\n"
+                         "        return gpuw->pGPA(gpuw->nextObject, funcName);\n"
+                         "    }\n"
+                         "}\n")
+        return "\n".join(func_body)
+
+    def _generate_layer_dispatch_table(self, prefix='xgl'):
+        func_body = []
+        func_body.append('static void initLayerTable()\n'
+                         '{\n'
+                         '    GetProcAddrType fpNextGPA;\n'
+                         '    fpNextGPA = pCurObj->pGPA;\n'
+                         '    assert(fpNextGPA);\n');
+
+        for name in xgl.icd_dispatch_table:
+            func_body.append('    %sType fp%s = fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (XGL_CHAR *) "%s%s");\n'
+                             '    nextTable.%s = fp%s;' % (name, name, prefix, name, name, name))
+
+        func_body.append("}\n")
+        return "\n".join(func_body)
+
+class LayerFuncsSubcommand(Subcommand):
+    def generate_header(self):
+        return '#include <xglLayer.h>\n#include "loader.h"'
+
+    def generate_body(self):
+        return self._generate_dispatch_entrypoints("static", True)
+
+class LayerDispatchSubcommand(Subcommand):
+    def generate_header(self):
+        return '#include "layer_wrappers.h"'
+
+    def generate_body(self):
+        return self._generate_layer_dispatch_table()
+
+class GenericLayerSubcommand(Subcommand):
+    def generate_header(self):
+        return '#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <assert.h>\n#include <pthread.h>\n#include "xglLayer.h"\n\nstatic XGL_LAYER_DISPATCH_TABLE nextTable;\nstatic XGL_BASE_LAYER_OBJECT *pCurObj;\nstatic pthread_once_t tabOnce = PTHREAD_ONCE_INIT;\n'
+
+    def generate_body(self):
+        body = [self._generate_layer_dispatch_table(),
+                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT", "generic"),
+                self._generate_layer_gpa_function()]
+
+        return "\n\n".join(body)
+
+class ApiDumpSubcommand(Subcommand):
+    def generate_header(self):
+        return '#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <assert.h>\n#include <pthread.h>\n#include "xglLayer.h"\n#include "xgl_string_helper.h"\n#include "xgl_struct_string_helper.h"\n\nstatic XGL_LAYER_DISPATCH_TABLE nextTable;\nstatic XGL_BASE_LAYER_OBJECT *pCurObj;\nstatic pthread_once_t tabOnce = PTHREAD_ONCE_INIT;\n'
+
+    def generate_body(self):
+        body = [self._generate_layer_dispatch_table(),
+                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT", "apidump"),
+                self._generate_layer_gpa_function()]
+
+        return "\n\n".join(body)
+
+class ObjectTrackerSubcommand(Subcommand):
+    def generate_header(self):
+        header_txt = []
+        header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <assert.h>\n#include <pthread.h>')
+        header_txt.append('#include "xglLayer.h"\n\nstatic XGL_LAYER_DISPATCH_TABLE nextTable;\nstatic XGL_BASE_LAYER_OBJECT *pCurObj;')
+        header_txt.append('static pthread_once_t tabOnce = PTHREAD_ONCE_INIT;\nstatic long long unsigned int object_track_index = 0;\n')
+        header_txt.append('typedef struct _objNode {')
+        header_txt.append('    XGL_VOID        *pObj;')
+        header_txt.append('    const char      *objType;')
+        header_txt.append('    uint64_t        numUses;')
+        header_txt.append('    struct _objNode *pNext;')
+        header_txt.append('} objNode;\n')
+        header_txt.append('static objNode *pObjLLHead = NULL;\n')
+        header_txt.append('static void ll_insert_obj(XGL_VOID* pObj, const char* type) {')
+        header_txt.append('    objNode* pNewObjNode = (objNode*)malloc(sizeof(objNode));')
+        header_txt.append('    pNewObjNode->pObj = pObj;')
+        header_txt.append('    pNewObjNode->objType = type;')
+        header_txt.append('    pNewObjNode->numUses = 0;')
+        header_txt.append('    pNewObjNode->pNext = pObjLLHead;')
+        header_txt.append('    pObjLLHead = pNewObjNode;')
+        header_txt.append('}\n')
+        header_txt.append('static void ll_increment_use_count(XGL_VOID* pObj) {')
+        header_txt.append('    objNode *pTrav = pObjLLHead;')
+        header_txt.append('    while (pTrav) {')
+        header_txt.append('        if (pTrav->pObj == pObj) {')
+        header_txt.append('            pTrav->numUses++;')
+        header_txt.append('            return;')
+        header_txt.append('        }')
+        header_txt.append('        pTrav = pTrav->pNext;')
+        header_txt.append('    }')
+        header_txt.append('    // If we do not find obj, insert it and then intrement count')
+        header_txt.append('    printf("INFO : Unable to increment count for obj %p, will add to list as UNKNOWN type and increment count\\n", pObj);')
+        header_txt.append('    ll_insert_obj(pObj, "UNKNOWN");')
+        header_txt.append('    ll_increment_use_count(pObj);')
+        header_txt.append('}')
+        header_txt.append('static uint64_t ll_get_obj_uses(XGL_VOID* pObj) {')
+        header_txt.append('    objNode *pTrav = pObjLLHead;')
+        header_txt.append('    while (pTrav) {')
+        header_txt.append('        if (pTrav->pObj == pObj) {')
+        header_txt.append('            return pTrav->numUses;')
+        header_txt.append('        }')
+        header_txt.append('        pTrav = pTrav->pNext;')
+        header_txt.append('    }')
+        header_txt.append('    return 0;')
+        header_txt.append('}')
+        header_txt.append('static void ll_remove_obj(XGL_VOID* pObj) {')
+        header_txt.append('    objNode *pTrav = pObjLLHead;')
+        header_txt.append('    objNode *pPrev = pObjLLHead;')
+        header_txt.append('    while (pTrav) {')
+        header_txt.append('        if (pTrav->pObj == pObj) {')
+        header_txt.append('            pPrev->pNext = pTrav->pNext;')
+        header_txt.append('            if (pObjLLHead == pTrav)')
+        header_txt.append('                pObjLLHead = pTrav->pNext;')
+        header_txt.append('            printf("OBJ_STAT Removed %s obj %p that was used %lu times.\\n", pTrav->objType, pTrav->pObj, pTrav->numUses);')
+        header_txt.append('            free(pTrav);')
+        header_txt.append('            return;')
+        header_txt.append('        }')
+        header_txt.append('        pPrev = pTrav;')
+        header_txt.append('        pTrav = pTrav->pNext;')
+        header_txt.append('    }')
+        header_txt.append('    printf("ERROR : Unable to remove obj %p\\n", pObj);')
+        header_txt.append('}')
+
+        return "\n".join(header_txt)
+
+    def generate_body(self):
+        body = [self._generate_layer_dispatch_table(),
+                self._generate_dispatch_entrypoints("XGL_LAYER_EXPORT", "objecttracker"),
+                self._generate_layer_gpa_function()]
+
+        return "\n\n".join(body)
+    
+def main():
+    subcommands = {
+            "layer-funcs" : LayerFuncsSubcommand,
+            "layer-dispatch" : LayerDispatchSubcommand,
+            "generic-layer" : GenericLayerSubcommand,
+            "api-dump" : ApiDumpSubcommand,
+            "object-tracker" : ObjectTrackerSubcommand,
+    }
+
+    if len(sys.argv) < 2 or sys.argv[1] not in subcommands:
+        print("Usage: %s <subcommand> [options]" % sys.argv[0])
+        print
+        print("Available sucommands are: %s" % " ".join(subcommands))
+        exit(1)
+
+    subcmd = subcommands[sys.argv[1]](sys.argv[2:])
+    subcmd.run()
+
+if __name__ == "__main__":
+    main()