Layers initial prototype.

Includes  an auto generated layer (GenericLayer) that wraps  all api calls.
Includes a basic handwritten layer (basicLayer)  that wraps a few apis.
Adds xglGetProcAddr as a new api, which is used to chain layers together.
All layers and loader implement  a dispatch table.

11 files changed, 1517 insertions, 36 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cbeb2cf..2a0db8d8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,3 +23,4 @@ endif()
 add_subdirectory(loader)
 add_subdirectory(icd)
 add_subdirectory(tests)
+add_subdirectory(layers)
diff --git a/icd/common/icd.h b/icd/common/icd.h
index ee68bf12..badef5f3 100644
--- a/icd/common/icd.h
+++ b/icd/common/icd.h
@@ -32,6 +32,7 @@
 
 #include <xgl.h>
 #include <xglDbg.h>
+#include <xglLayer.h>
 
 #include "icd-dispatch-table.h"
 
diff --git a/include/xgl.h b/include/xgl.h
index 7fb33cc7..7f3986c5 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -1761,6 +1761,10 @@ typedef struct _XGL_DISPATCH_INDIRECT_CMD
 // ------------------------------------------------------------------------------------------------
 // API functions
 
+void * XGLAPI xglGetProcAddr(
+    XGL_PHYSICAL_GPU gpu,
+    const XGL_CHAR * pName);
+
 // GPU initialization
 
 XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
diff --git a/include/xglLayer.h b/include/xglLayer.h
new file mode 100644
index 00000000..b762e57b
--- /dev/null
+++ b/include/xglLayer.h
@@ -0,0 +1,274 @@
+/* Need to define dispatch table
+ * Core struct can then have ptr to dispatch table at the top
+ * Along with object ptrs for current and next OBJ
+ */
+#pragma once
+
+#include "xgl.h"
+#include "xglDbg.h"
+#include "xglWsiX11Ext.h"
+#if defined(__GNUC__) && __GNUC__ >= 4
+#  define XGL_LAYER_EXPORT __attribute__((visibility("default")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#  define XGL_LAYER_EXPORT __attribute__((visibility("default")))
+#else
+#  define XGL_LAYER_EXPORT
+#endif
+
+typedef void * (XGLAPI *GetProcAddrType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR * pName);
+typedef XGL_RESULT (XGLAPI *InitAndEnumerateGpusType)(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb, XGL_UINT maxGpus, XGL_UINT* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
+typedef XGL_RESULT (XGLAPI *GetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *CreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
+typedef XGL_RESULT (XGLAPI *DestroyDeviceType)(XGL_DEVICE device);
+typedef XGL_RESULT (XGLAPI *GetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pExtName);
+typedef XGL_RESULT (XGLAPI *GetDeviceQueueType)(XGL_DEVICE device, XGL_QUEUE_TYPE queueType, XGL_UINT queueIndex, XGL_QUEUE* pQueue);
+typedef XGL_RESULT (XGLAPI *QueueSubmitType)(XGL_QUEUE queue, XGL_UINT cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence);
+typedef XGL_RESULT (XGLAPI *QueueSetGlobalMemReferencesType)(XGL_QUEUE queue, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs);
+typedef XGL_RESULT (XGLAPI *QueueWaitIdleType)(XGL_QUEUE queue);
+typedef XGL_RESULT (XGLAPI *DeviceWaitIdleType)(XGL_DEVICE device);
+typedef XGL_RESULT (XGLAPI *GetMemoryHeapCountType)(XGL_DEVICE device, XGL_UINT* pCount);
+typedef XGL_RESULT (XGLAPI *GetMemoryHeapInfoType)(XGL_DEVICE device, XGL_UINT heapId, XGL_MEMORY_HEAP_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *AllocMemoryType)(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem);
+typedef XGL_RESULT (XGLAPI *FreeMemoryType)(XGL_GPU_MEMORY mem);
+typedef XGL_RESULT (XGLAPI *SetMemoryPriorityType)(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority);
+typedef XGL_RESULT (XGLAPI *MapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData);
+typedef XGL_RESULT (XGLAPI *UnmapMemoryType)(XGL_GPU_MEMORY mem);
+typedef XGL_RESULT (XGLAPI *PinSystemMemoryType)(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem);
+typedef XGL_RESULT (XGLAPI *RemapVirtualMemoryPagesType)(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);
+typedef XGL_RESULT (XGLAPI *GetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
+typedef XGL_RESULT (XGLAPI *OpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
+typedef XGL_RESULT (XGLAPI *OpenSharedQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
+typedef XGL_RESULT (XGLAPI *OpenPeerMemoryType)(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
+typedef XGL_RESULT (XGLAPI *OpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
+typedef XGL_RESULT (XGLAPI *DestroyObjectType)(XGL_OBJECT object);
+typedef XGL_RESULT (XGLAPI *GetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *BindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
+typedef XGL_RESULT (XGLAPI *CreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
+typedef XGL_RESULT (XGLAPI *GetFenceStatusType)(XGL_FENCE fence);
+typedef XGL_RESULT (XGLAPI *WaitForFencesType)(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout);
+typedef XGL_RESULT (XGLAPI *CreateQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
+typedef XGL_RESULT (XGLAPI *SignalQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
+typedef XGL_RESULT (XGLAPI *WaitQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
+typedef XGL_RESULT (XGLAPI *CreateEventType)(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent);
+typedef XGL_RESULT (XGLAPI *GetEventStatusType)(XGL_EVENT event);
+typedef XGL_RESULT (XGLAPI *SetEventType)(XGL_EVENT event);
+typedef XGL_RESULT (XGLAPI *ResetEventType)(XGL_EVENT event);
+typedef XGL_RESULT (XGLAPI *CreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool);
+typedef XGL_RESULT (XGLAPI *GetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *GetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *CreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage);
+typedef XGL_RESULT (XGLAPI *GetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *CreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView);
+typedef XGL_RESULT (XGLAPI *CreateColorAttachmentViewType)(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView);
+typedef XGL_RESULT (XGLAPI *CreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView);
+typedef XGL_RESULT (XGLAPI *CreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader);
+typedef XGL_RESULT (XGLAPI *CreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
+typedef XGL_RESULT (XGLAPI *CreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
+typedef XGL_RESULT (XGLAPI *StorePipelineType)(XGL_PIPELINE pipeline, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *LoadPipelineType)(XGL_DEVICE device, XGL_SIZE dataSize, const XGL_VOID* pData, XGL_PIPELINE* pPipeline);
+typedef XGL_RESULT (XGLAPI *CreatePipelineDeltaType)(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta);
+typedef XGL_RESULT (XGLAPI *CreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
+typedef XGL_RESULT (XGLAPI *CreateDescriptorSetType)(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET* pDescriptorSet);
+typedef XGL_VOID (XGLAPI *BeginDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
+typedef XGL_VOID (XGLAPI *EndDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
+typedef XGL_VOID (XGLAPI *AttachSamplerDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers);
+typedef XGL_VOID (XGLAPI *AttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
+typedef XGL_VOID (XGLAPI *AttachMemoryViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
+typedef XGL_VOID (XGLAPI *AttachNestedDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
+typedef XGL_VOID (XGLAPI *ClearDescriptorSetSlotsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount);
+typedef XGL_RESULT (XGLAPI *CreateViewportStateType)(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *CreateRasterStateType)(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *CreateMsaaStateType)(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *CreateColorBlendStateType)(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *CreateDepthStencilStateType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
+typedef XGL_RESULT (XGLAPI *CreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer);
+typedef XGL_RESULT (XGLAPI *BeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_FLAGS flags);
+typedef XGL_RESULT (XGLAPI *EndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
+typedef XGL_RESULT (XGLAPI *ResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
+typedef XGL_VOID (XGLAPI *CmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
+typedef XGL_VOID (XGLAPI *CmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
+typedef XGL_VOID (XGLAPI *CmdBindStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state);
+typedef XGL_VOID (XGLAPI *CmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset);
+typedef XGL_VOID (XGLAPI *CmdBindDynamicMemoryViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
+typedef XGL_VOID (XGLAPI *CmdBindIndexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
+typedef XGL_VOID (XGLAPI *CmdBindAttachmentsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT colorAttachmentCount, const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments, const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment);
+typedef XGL_VOID (XGLAPI *CmdPrepareMemoryRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
+typedef XGL_VOID (XGLAPI *CmdPrepareImagesType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
+typedef XGL_VOID (XGLAPI *CmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
+typedef XGL_VOID (XGLAPI *CmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
+typedef XGL_VOID (XGLAPI *CmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
+typedef XGL_VOID (XGLAPI *CmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
+typedef XGL_VOID (XGLAPI *CmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT x, XGL_UINT y, XGL_UINT z);
+typedef XGL_VOID (XGLAPI *CmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
+typedef XGL_VOID (XGLAPI *CmdCopyMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *CmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *CmdCopyMemoryToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *CmdCopyImageToMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *CmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState);
+typedef XGL_VOID (XGLAPI *CmdUpdateMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
+typedef XGL_VOID (XGLAPI *CmdFillMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
+typedef XGL_VOID (XGLAPI *CmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef XGL_VOID (XGLAPI *CmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef XGL_VOID (XGLAPI *CmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef XGL_VOID (XGLAPI *CmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects);
+typedef XGL_VOID (XGLAPI *CmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
+typedef XGL_VOID (XGLAPI *CmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
+typedef XGL_VOID (XGLAPI *CmdMemoryAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
+typedef XGL_VOID (XGLAPI *CmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags);
+typedef XGL_VOID (XGLAPI *CmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot);
+typedef XGL_VOID (XGLAPI *CmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount);
+typedef XGL_VOID (XGLAPI *CmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
+typedef XGL_VOID (XGLAPI *CmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData);
+typedef XGL_VOID (XGLAPI *CmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY srcMem, XGL_GPU_SIZE srcOffset);
+typedef XGL_VOID (XGLAPI *CmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
+typedef XGL_RESULT (XGLAPI *DbgSetValidationLevelType)(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel);
+typedef XGL_RESULT (XGLAPI *DbgRegisterMsgCallbackType)(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, XGL_VOID* pUserData);
+typedef XGL_RESULT (XGLAPI *DbgUnregisterMsgCallbackType)(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
+typedef XGL_RESULT (XGLAPI *DbgSetMessageFilterType)(XGL_DEVICE device, XGL_INT msgCode, XGL_DBG_MSG_FILTER filter);
+typedef XGL_RESULT (XGLAPI *DbgSetObjectTagType)(XGL_BASE_OBJECT object, XGL_SIZE tagSize, const XGL_VOID* pTag);
+typedef XGL_RESULT (XGLAPI *DbgSetGlobalOptionType)(XGL_DBG_GLOBAL_OPTION dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *DbgSetDeviceOptionType)(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData);
+typedef XGL_VOID (XGLAPI *CmdDbgMarkerBeginType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CHAR* pMarker);
+typedef XGL_VOID (XGLAPI *CmdDbgMarkerEndType)(XGL_CMD_BUFFER cmdBuffer);
+typedef XGL_RESULT (XGLAPI *WsiX11AssociateConnectionType)(XGL_PHYSICAL_GPU gpu, const XGL_WSI_X11_CONNECTION_INFO* pConnectionInfo);
+typedef XGL_RESULT (XGLAPI *WsiX11GetMSCType)(XGL_DEVICE device, xcb_randr_crtc_t crtc, XGL_UINT64* pMsc);
+typedef XGL_RESULT (XGLAPI *WsiX11CreatePresentableImageType)(XGL_DEVICE device, const XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
+typedef XGL_RESULT (XGLAPI *WsiX11QueuePresentType)(XGL_QUEUE queue, const XGL_WSI_X11_PRESENT_INFO* pPresentInfo, XGL_FENCE fence);
+
+typedef struct _XGL_BASE_LAYER_OBJECT
+{
+    GetProcAddrType pGPA;
+    XGL_BASE_OBJECT nextObject;
+    XGL_BASE_OBJECT baseObject;
+} XGL_BASE_LAYER_OBJECT;
+
+typedef struct _XGL_LAYER_DISPATCH_TABLE
+{
+    GetProcAddrType GetProcAddr;
+    InitAndEnumerateGpusType InitAndEnumerateGpus;
+    GetGpuInfoType GetGpuInfo;
+    CreateDeviceType CreateDevice;
+    DestroyDeviceType DestroyDevice;
+    GetExtensionSupportType GetExtensionSupport;
+    GetDeviceQueueType GetDeviceQueue;
+    QueueSubmitType QueueSubmit;
+    QueueSetGlobalMemReferencesType QueueSetGlobalMemReferences;
+    QueueWaitIdleType QueueWaitIdle;
+    DeviceWaitIdleType DeviceWaitIdle;
+    GetMemoryHeapCountType GetMemoryHeapCount;
+    GetMemoryHeapInfoType GetMemoryHeapInfo;
+    AllocMemoryType AllocMemory;
+    FreeMemoryType FreeMemory;
+    SetMemoryPriorityType SetMemoryPriority;
+    MapMemoryType MapMemory;
+    UnmapMemoryType UnmapMemory;
+    PinSystemMemoryType PinSystemMemory;
+    RemapVirtualMemoryPagesType RemapVirtualMemoryPages;
+    GetMultiGpuCompatibilityType GetMultiGpuCompatibility;
+    OpenSharedMemoryType OpenSharedMemory;
+    OpenSharedQueueSemaphoreType OpenSharedQueueSemaphore;
+    OpenPeerMemoryType OpenPeerMemory;
+    OpenPeerImageType OpenPeerImage;
+    DestroyObjectType DestroyObject;
+    GetObjectInfoType GetObjectInfo;
+    BindObjectMemoryType BindObjectMemory;
+    CreateFenceType CreateFence;
+    GetFenceStatusType GetFenceStatus;
+    WaitForFencesType WaitForFences;
+    CreateQueueSemaphoreType CreateQueueSemaphore;
+    SignalQueueSemaphoreType SignalQueueSemaphore;
+    WaitQueueSemaphoreType WaitQueueSemaphore;
+    CreateEventType CreateEvent;
+    GetEventStatusType GetEventStatus;
+    SetEventType SetEvent;
+    ResetEventType ResetEvent;
+    CreateQueryPoolType CreateQueryPool;
+    GetQueryPoolResultsType GetQueryPoolResults;
+    GetFormatInfoType GetFormatInfo;
+    CreateImageType CreateImage;
+    GetImageSubresourceInfoType GetImageSubresourceInfo;
+    CreateImageViewType CreateImageView;
+    CreateColorAttachmentViewType CreateColorAttachmentView;
+    CreateDepthStencilViewType CreateDepthStencilView;
+    CreateShaderType CreateShader;
+    CreateGraphicsPipelineType CreateGraphicsPipeline;
+    CreateComputePipelineType CreateComputePipeline;
+    StorePipelineType StorePipeline;
+    LoadPipelineType LoadPipeline;
+    CreatePipelineDeltaType CreatePipelineDelta;
+    CreateSamplerType CreateSampler;
+    CreateDescriptorSetType CreateDescriptorSet;
+    BeginDescriptorSetUpdateType BeginDescriptorSetUpdate;
+    EndDescriptorSetUpdateType EndDescriptorSetUpdate;
+    AttachSamplerDescriptorsType AttachSamplerDescriptors;
+    AttachImageViewDescriptorsType AttachImageViewDescriptors;
+    AttachMemoryViewDescriptorsType AttachMemoryViewDescriptors;
+    AttachNestedDescriptorsType AttachNestedDescriptors;
+    ClearDescriptorSetSlotsType ClearDescriptorSetSlots;
+    CreateViewportStateType CreateViewportState;
+    CreateRasterStateType CreateRasterState;
+    CreateMsaaStateType CreateMsaaState;
+    CreateColorBlendStateType CreateColorBlendState;
+    CreateDepthStencilStateType CreateDepthStencilState;
+    CreateCommandBufferType CreateCommandBuffer;
+    BeginCommandBufferType BeginCommandBuffer;
+    EndCommandBufferType EndCommandBuffer;
+    ResetCommandBufferType ResetCommandBuffer;
+    CmdBindPipelineType CmdBindPipeline;
+    CmdBindPipelineDeltaType CmdBindPipelineDelta;
+    CmdBindStateObjectType CmdBindStateObject;
+    CmdBindDescriptorSetType CmdBindDescriptorSet;
+    CmdBindDynamicMemoryViewType CmdBindDynamicMemoryView;
+    CmdBindIndexDataType CmdBindIndexData;
+    CmdBindAttachmentsType CmdBindAttachments;
+    CmdPrepareMemoryRegionsType CmdPrepareMemoryRegions;
+    CmdPrepareImagesType CmdPrepareImages;
+    CmdDrawType CmdDraw;
+    CmdDrawIndexedType CmdDrawIndexed;
+    CmdDrawIndirectType CmdDrawIndirect;
+    CmdDrawIndexedIndirectType CmdDrawIndexedIndirect;
+    CmdDispatchType CmdDispatch;
+    CmdDispatchIndirectType CmdDispatchIndirect;
+    CmdCopyMemoryType CmdCopyMemory;
+    CmdCopyImageType CmdCopyImage;
+    CmdCopyMemoryToImageType CmdCopyMemoryToImage;
+    CmdCopyImageToMemoryType CmdCopyImageToMemory;
+    CmdCloneImageDataType CmdCloneImageData;
+    CmdUpdateMemoryType CmdUpdateMemory;
+    CmdFillMemoryType CmdFillMemory;
+    CmdClearColorImageType CmdClearColorImage;
+    CmdClearColorImageRawType CmdClearColorImageRaw;
+    CmdClearDepthStencilType CmdClearDepthStencil;
+    CmdResolveImageType CmdResolveImage;
+    CmdSetEventType CmdSetEvent;
+    CmdResetEventType CmdResetEvent;
+    CmdMemoryAtomicType CmdMemoryAtomic;
+    CmdBeginQueryType CmdBeginQuery;
+    CmdEndQueryType CmdEndQuery;
+    CmdResetQueryPoolType CmdResetQueryPool;
+    CmdWriteTimestampType CmdWriteTimestamp;
+    CmdInitAtomicCountersType CmdInitAtomicCounters;
+    CmdLoadAtomicCountersType CmdLoadAtomicCounters;
+    CmdSaveAtomicCountersType CmdSaveAtomicCounters;
+    DbgSetValidationLevelType DbgSetValidationLevel;
+    DbgRegisterMsgCallbackType DbgRegisterMsgCallback;
+    DbgUnregisterMsgCallbackType DbgUnregisterMsgCallback;
+    DbgSetMessageFilterType DbgSetMessageFilter;
+    DbgSetObjectTagType DbgSetObjectTag;
+    DbgSetGlobalOptionType DbgSetGlobalOption;
+    DbgSetDeviceOptionType DbgSetDeviceOption;
+    CmdDbgMarkerBeginType CmdDbgMarkerBegin;
+    CmdDbgMarkerEndType CmdDbgMarkerEnd;
+    WsiX11AssociateConnectionType WsiX11AssociateConnection;
+    WsiX11GetMSCType WsiX11GetMSC;
+    WsiX11CreatePresentableImageType WsiX11CreatePresentableImage;
+    WsiX11QueuePresentType WsiX11QueuePresent;
+} XGL_LAYER_DISPATCH_TABLE;
+
+// ------------------------------------------------------------------------------------------------
+// API functions
+XGL_RESULT xglEnumerateLayers(
+    XGL_PHYSICAL_GPU gpu,
+    XGL_SIZE maxLayerCount,
+    XGL_CHAR* const* pOutLayers,
+    XGL_SIZE* pOutLayerCount);
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
new file mode 100644
index 00000000..ebbfc42d
--- /dev/null
+++ b/layers/CMakeLists.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required (VERSION 2.8.11)
+
+add_custom_command(OUTPUT generic_layer.c
+	COMMAND ${PROJECT_SOURCE_DIR}/xgl-generate.py generic-layer > generic_layer.c
+	           DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py
+	                   ${PROJECT_SOURCE_DIR}/xgl.py)
+
+set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I ../include")
+
+add_library (XGLLayerBasic SHARED basic_plugin.c)
+add_library (XGLLayerGeneric SHARED generic_layer.c)
+#add_library (XGLLayerObjectTrack SHARED object_track.c)
+
diff --git a/layers/basic_plugin.c b/layers/basic_plugin.c
new file mode 100644
index 00000000..32ada03d
--- /dev/null
+++ b/layers/basic_plugin.c
@@ -0,0 +1,434 @@
+#include <stdio.h>
+#include <dlfcn.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <pthread.h>
+#include "xglLayer.h"
+
+static XGL_LAYER_DISPATCH_TABLE myTable;
+static XGL_BASE_LAYER_OBJECT *pCurObj;
+static pthread_once_t tabOnce = PTHREAD_ONCE_INIT;
+
+static void initLayerTable()
+{
+    GetProcAddrType fpGPA;
+
+    //memset(&myTable, 0 , sizeof(myTable));
+
+    //todo init the entire table to next entrypoint
+    fpGPA = pCurObj->pGPA;
+    assert(fpGPA);
+    // Layer
+    myTable.GetProcAddr = fpGPA;
+    myTable.InitAndEnumerateGpus = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglInitAndEnumerateGpus");
+    myTable.GetGpuInfo = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetGpuInfo");
+    myTable.CreateDevice = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateDevice");
+    myTable.DestroyDevice = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDestroyDevice");
+    myTable.GetExtensionSupport = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetExtensionSupport");
+    myTable.GetDeviceQueue = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetDeviceQueue");
+    myTable.QueueSubmit = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglQueueSubmit");
+    myTable.QueueSetGlobalMemReferences = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglQueueSetGlobalMemReferences");
+    myTable.QueueWaitIdle = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglQueueWaitIdle");
+    myTable.DeviceWaitIdle = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDeviceWaitIdle");
+    myTable.GetMemoryHeapCount = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetMemoryHeapCount");
+    myTable.GetMemoryHeapInfo = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetMemoryHeapInfo");
+    myTable.AllocMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglAllocMemory");
+    myTable.FreeMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglFreeMemory");
+    myTable.SetMemoryPriority = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglSetMemoryPriority");
+    myTable.MapMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglMapMemory");
+    myTable.UnmapMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglUnmapMemory");
+    myTable.PinSystemMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglPinSystemMemory");
+    myTable.RemapVirtualMemoryPages = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglRemapVirtualMemoryPages");
+    myTable.GetMultiGpuCompatibility = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetMultiGpuCompatibility");
+    myTable.OpenSharedMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglOpenSharedMemory");
+    myTable.OpenSharedQueueSemaphore = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglOpenSharedQueueSemaphore");
+    myTable.OpenPeerMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglOpenPeerMemory");
+    myTable.OpenPeerImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglOpenPeerImage");
+    myTable.DestroyObject = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDestroyObject");
+    myTable.GetObjectInfo = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetObjectInfo");
+    myTable.BindObjectMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglBindObjectMemory");
+    myTable.CreateFence = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateFence");
+    myTable.GetFenceStatus = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetFenceStatus");
+    myTable.WaitForFences = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglWaitForFences");
+    myTable.CreateQueueSemaphore = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateQueueSemaphore");
+    myTable.SignalQueueSemaphore = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglSignalQueueSemaphore");
+    myTable.WaitQueueSemaphore = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglWaitQueueSemaphore");
+    myTable.CreateEvent = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateEvent");
+    myTable.GetEventStatus = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetEventStatus");
+    myTable.SetEvent = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglSetEvent");
+    myTable.ResetEvent = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglResetEvent");
+    myTable.CreateQueryPool = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateQueryPool");
+    myTable.GetQueryPoolResults = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetQueryPoolResults");
+    myTable.GetFormatInfo = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetFormatInfo");
+    myTable.CreateImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateImage");
+    myTable.GetImageSubresourceInfo = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglGetImageSubresourceInfo");
+    myTable.CreateImageView = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateImageView");
+    myTable.CreateColorAttachmentView = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateColorAttachmentView");
+    myTable.CreateDepthStencilView = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateDepthStencilView");
+    myTable.CreateShader = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateShader");
+    myTable.CreateGraphicsPipeline = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateGraphicsPipeline");
+    myTable.CreateComputePipeline = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateComputePipeline");
+    myTable.StorePipeline = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglStorePipeline");
+    myTable.LoadPipeline = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglLoadPipeline");
+    myTable.CreatePipelineDelta = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreatePipelineDelta");
+    myTable.CreateSampler = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateSampler");
+    myTable.CreateDescriptorSet = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateDescriptorSet");
+    myTable.BeginDescriptorSetUpdate = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglBeginDescriptorSetUpdate");
+    myTable.EndDescriptorSetUpdate = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglEndDescriptorSetUpdate");
+    myTable.AttachSamplerDescriptors = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglAttachSamplerDescriptors");
+    myTable.AttachImageViewDescriptors = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglAttachImageViewDescriptors");
+    myTable.AttachMemoryViewDescriptors = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglAttachMemoryViewDescriptors");
+    myTable.AttachNestedDescriptors = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglAttachNestedDescriptors");
+    myTable.ClearDescriptorSetSlots = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglClearDescriptorSetSlots");
+    myTable.CreateViewportState = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateViewportState");
+    myTable.CreateRasterState = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateRasterState");
+    myTable.CreateMsaaState = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateMsaaState");
+    myTable.CreateColorBlendState = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateColorBlendState");
+    myTable.CreateDepthStencilState = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateDepthStencilState");
+    myTable.CreateCommandBuffer = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCreateCommandBuffer");
+    myTable.BeginCommandBuffer = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglBeginCommandBuffer");
+    myTable.EndCommandBuffer = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglEndCommandBuffer");
+    myTable.ResetCommandBuffer = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglResetCommandBuffer");
+    myTable.CmdBindPipeline = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindPipeline");
+    myTable.CmdBindPipelineDelta = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindPipelineDelta");
+    myTable.CmdBindStateObject = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindStateObject");
+    myTable.CmdBindDescriptorSet = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindDescriptorSet");
+    myTable.CmdBindDynamicMemoryView = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindDynamicMemoryView");
+    myTable.CmdBindIndexData = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindIndexData");
+    myTable.CmdBindAttachments = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBindAttachments");
+    myTable.CmdPrepareMemoryRegions = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdPrepareMemoryRegions");
+    myTable.CmdPrepareImages = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdPrepareImages");
+    myTable.CmdDraw = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDraw");
+    myTable.CmdDrawIndexed = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDrawIndexed");
+    myTable.CmdDrawIndirect = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDrawIndirect");
+    myTable.CmdDrawIndexedIndirect = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDrawIndexedIndirect");
+    myTable.CmdDispatch = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDispatch");
+    myTable.CmdDispatchIndirect = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDispatchIndirect");
+    myTable.CmdCopyMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdCopyMemory");
+    myTable.CmdCopyImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdCopyImage");
+    myTable.CmdCopyMemoryToImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdCopyMemoryToImage");
+    myTable.CmdCopyImageToMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdCopyImageToMemory");
+    myTable.CmdCloneImageData = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdCloneImageData");
+    myTable.CmdUpdateMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdUpdateMemory");
+    myTable.CmdFillMemory = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdFillMemory");
+    myTable.CmdClearColorImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdClearColorImage");
+    myTable.CmdClearColorImageRaw = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdClearColorImageRaw");
+    myTable.CmdClearDepthStencil = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdClearDepthStencil");
+    myTable.CmdResolveImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdResolveImage");
+    myTable.CmdSetEvent = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdSetEvent");
+    myTable.CmdResetEvent = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdResetEvent");
+    myTable.CmdMemoryAtomic = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdMemoryAtomic");
+    myTable.CmdBeginQuery = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdBeginQuery");
+    myTable.CmdEndQuery = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdEndQuery");
+    myTable.CmdResetQueryPool = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdResetQueryPool");
+    myTable.CmdWriteTimestamp = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdWriteTimestamp");
+    myTable.CmdInitAtomicCounters = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdInitAtomicCounters");
+    myTable.CmdLoadAtomicCounters = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdLoadAtomicCounters");
+    myTable.CmdSaveAtomicCounters = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdSaveAtomicCounters");
+    myTable.DbgSetValidationLevel = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgSetValidationLevel");
+    myTable.DbgRegisterMsgCallback = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgRegisterMsgCallback");
+    myTable.DbgUnregisterMsgCallback = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgUnregisterMsgCallback");
+    myTable.DbgSetMessageFilter = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgSetMessageFilter");
+    myTable.DbgSetObjectTag = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgSetObjectTag");
+    myTable.DbgSetGlobalOption = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgSetGlobalOption");
+    myTable.DbgSetDeviceOption = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglDbgSetDeviceOption");
+    myTable.CmdDbgMarkerBegin = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDbgMarkerBegin");
+    myTable.CmdDbgMarkerEnd = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglCmdDbgMarkerEnd");
+    myTable.WsiX11AssociateConnection = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglWsiX11AssociateConnection");
+    myTable.WsiX11GetMSC = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglWsiX11GetMSC");
+    myTable.WsiX11CreatePresentableImage = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglWsiX11CreatePresentableImage");
+    myTable.WsiX11QueuePresent = fpGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (const XGL_CHAR *) "xglWsiX11QueuePresent");
+#if 0
+    fpNextCD = fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (XGL_CHAR *) "xglCreateDevice");
+    myTable.CreateDevice = fpNextCD;
+    fpNextGGI = fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (XGL_CHAR *) "xglGetGpuInfo");
+    myTable.GetGpuInfo = fpNextGGI;
+    fpNextGFI = fpNextGPA((XGL_PHYSICAL_GPU) pCurObj->nextObject, (XGL_CHAR *) "xglGetFormatInfo");
+    myTable.GetFormatInfo = fpNextGFI;
+#endif
+    return;
+}
+
+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 wrapped xglCreateDevice() call w/ gpu: %p\n", (void*)gpu);
+    pCurObj = gpuw;
+    pthread_once(&tabOnce, initLayerTable);
+    XGL_RESULT result = myTable.GetGpuInfo((XGL_PHYSICAL_GPU)gpuw->nextObject, infoType, pDataSize, pData);
+    printf("Completed wrapped xglCreateDevice() call w/ gpu: %p\n", (void*)gpu);
+    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 wrapped xglCreateDevice() call w/ gpu: %p\n", (void*)gpu);
+    pCurObj = gpuw;
+    pthread_once(&tabOnce, initLayerTable); 
+    XGL_RESULT result = myTable.CreateDevice((XGL_PHYSICAL_GPU)gpuw->nextObject, pCreateInfo, pDevice);
+    printf("Completed wrapped xglCreateDevice() call w/ pDevice: %p\n", (void*)pDevice);
+    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)
+{
+    printf("At start of wrapped xglGetFormatInfo() call w/ device: %p\n", (void*)device);
+    XGL_RESULT result = myTable.GetFormatInfo(device, format, infoType, pDataSize, pData);
+    printf("Completed wrapped xglGetFormatInfo() call w/ device: %p\n", (void*)device);
+       return result;
+}
+
+XGL_LAYER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pName) {
+    XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+    if (gpu == NULL)
+        return NULL;
+    pCurObj = gpuw;
+    pthread_once(&tabOnce, initLayerTable);
+    if (!strncmp("xglGetProcAddr", (const char *) pName, sizeof("xglGetProcAddr")))
+        return xglGetProcAddr;
+    else if (!strncmp("xglInitAndEnumerateGpus", (const char *) pName, sizeof("xglInitAndEnumerateGpus")))
+        return myTable.InitAndEnumerateGpus;
+    if (!strncmp("xglGetGpuInfo", (const char *) pName, sizeof ("xglGetGpuInfo")))
+        return xglGetGpuInfo;
+    else if (!strncmp("xglCreateDevice", (const char *) pName, sizeof ("xglCreateDevice")))
+        return xglCreateDevice;
+    else if (!strncmp("xglDestroyDevice", (const char *) pName, sizeof ("xglDestroyDevice")))
+        return myTable.DestroyDevice;
+    else if (!strncmp("xglGetExtensionSupport", (const char *) pName, sizeof ("xglGetExtensionSupport")))
+        return myTable.GetExtensionSupport;
+    else if (!strncmp("xglGetDeviceQueue", (const char *) pName, sizeof ("xglGetDeviceQueue")))
+        return myTable.GetDeviceQueue;
+    else if (!strncmp("xglQueueSubmit", (const char *) pName, sizeof ("xglQueueSubmit")))
+        return myTable.QueueSubmit;
+    else if (!strncmp("xglQueueSetGlobalMemReferences", (const char *) pName, sizeof ("xglQueueSetGlobalMemReferences")))
+        return myTable.QueueSetGlobalMemReferences;
+    else if (!strncmp("xglQueueWaitIdle", (const char *) pName, sizeof ("xglQueueWaitIdle")))
+        return myTable.QueueWaitIdle;
+    else if (!strncmp("xglDeviceWaitIdle", (const char *) pName, sizeof ("xglDeviceWaitIdle")))
+        return myTable.DeviceWaitIdle;
+    else if (!strncmp("xglGetMemoryHeapCount", (const char *) pName, sizeof ("xglGetMemoryHeapCount")))
+        return myTable.GetMemoryHeapCount;
+    else if (!strncmp("xglGetMemoryHeapInfo", (const char *) pName, sizeof ("xglGetMemoryHeapInfo")))
+        return myTable.GetMemoryHeapInfo;
+    else if (!strncmp("xglAllocMemory", (const char *) pName, sizeof ("xglAllocMemory")))
+        return myTable.AllocMemory;
+    else if (!strncmp("xglFreeMemory", (const char *) pName, sizeof ("xglFreeMemory")))
+        return myTable.FreeMemory;
+    else if (!strncmp("xglSetMemoryPriority", (const char *) pName, sizeof ("xglSetMemoryPriority")))
+        return myTable.SetMemoryPriority;
+    else if (!strncmp("xglMapMemory", (const char *) pName, sizeof ("xglMapMemory")))
+        return myTable.MapMemory;
+    else if (!strncmp("xglUnmapMemory", (const char *) pName, sizeof ("xglUnmapMemory")))
+        return myTable.UnmapMemory;
+    else if (!strncmp("xglPinSystemMemory", (const char *) pName, sizeof ("xglPinSystemMemory")))
+        return myTable.PinSystemMemory;
+    else if (!strncmp("xglRemapVirtualMemoryPages", (const char *) pName, sizeof ("xglRemapVirtualMemoryPages")))
+        return myTable.RemapVirtualMemoryPages;
+    else if (!strncmp("xglGetMultiGpuCompatibility", (const char *) pName, sizeof ("xglGetMultiGpuCompatibility")))
+        return myTable.GetMultiGpuCompatibility;
+    else if (!strncmp("xglOpenSharedMemory", (const char *) pName, sizeof ("xglOpenSharedMemory")))
+        return myTable.OpenSharedMemory;
+    else if (!strncmp("xglOpenSharedQueueSemaphore", (const char *) pName, sizeof ("xglOpenSharedQueueSemaphore")))
+        return myTable.OpenSharedQueueSemaphore;
+    else if (!strncmp("xglOpenPeerMemory", (const char *) pName, sizeof ("xglOpenPeerMemory")))
+        return myTable.OpenPeerMemory;
+    else if (!strncmp("xglOpenPeerImage", (const char *) pName, sizeof ("xglOpenPeerImage")))
+        return myTable.OpenPeerImage;
+    else if (!strncmp("xglDestroyObject", (const char *) pName, sizeof ("xglDestroyObject")))
+        return myTable.DestroyObject;
+    else if (!strncmp("xglGetObjectInfo", (const char *) pName, sizeof ("xglGetObjectInfo")))
+        return myTable.GetObjectInfo;
+    else if (!strncmp("xglBindObjectMemory", (const char *) pName, sizeof ("xglBindObjectMemory")))
+        return myTable.BindObjectMemory;
+    else if (!strncmp("xglCreateFence", (const char *) pName, sizeof ("xgllCreateFence")))
+        return myTable.CreateFence;
+    else if (!strncmp("xglGetFenceStatus", (const char *) pName, sizeof ("xglGetFenceStatus")))
+        return myTable.GetFenceStatus;
+    else if (!strncmp("xglWaitForFences", (const char *) pName, sizeof ("xglWaitForFences")))
+        return myTable.WaitForFences;
+    else if (!strncmp("xglCreateQueueSemaphore", (const char *) pName, sizeof ("xgllCreateQueueSemaphore")))
+        return myTable.CreateQueueSemaphore;
+    else if (!strncmp("xglSignalQueueSemaphore", (const char *) pName, sizeof ("xglSignalQueueSemaphore")))
+        return myTable.SignalQueueSemaphore;
+    else if (!strncmp("xglWaitQueueSemaphore", (const char *) pName, sizeof ("xglWaitQueueSemaphore")))
+        return myTable.WaitQueueSemaphore;
+    else if (!strncmp("xglCreateEvent", (const char *) pName, sizeof ("xgllCreateEvent")))
+        return myTable.CreateEvent;
+    else if (!strncmp("xglGetEventStatus", (const char *) pName, sizeof ("xglGetEventStatus")))
+        return myTable.GetEventStatus;
+    else if (!strncmp("xglSetEvent", (const char *) pName, sizeof ("xglSetEvent")))
+        return myTable.SetEvent;
+    else if (!strncmp("xglResetEvent", (const char *) pName, sizeof ("xgllResetEvent")))
+        return myTable.ResetEvent;
+    else if (!strncmp("xglCreateQueryPool", (const char *) pName, sizeof ("xglCreateQueryPool")))
+        return myTable.CreateQueryPool;
+    else if (!strncmp("xglGetQueryPoolResults", (const char *) pName, sizeof ("xglGetQueryPoolResults")))
+        return myTable.GetQueryPoolResults;
+    else if (!strncmp("xglGetFormatInfo", (const char *) pName, sizeof ("xgllGetFormatInfo")))
+        return xglGetFormatInfo;
+    else if (!strncmp("xglCreateImage", (const char *) pName, sizeof ("xglCreateImage")))
+        return myTable.CreateImage;
+    else if (!strncmp("xglGetImageSubresourceInfo", (const char *) pName, sizeof ("xglGetImageSubresourceInfo")))
+        return myTable.GetImageSubresourceInfo;
+    else if (!strncmp("xglCreateImageView", (const char *) pName, sizeof ("xglCreateImageView")))
+        return myTable.CreateImageView;
+    else if (!strncmp("xglCreateColorAttachmentView", (const char *) pName, sizeof ("xglCreateColorAttachmentView")))
+        return myTable.CreateColorAttachmentView;
+    else if (!strncmp("xglCreateDepthStencilView", (const char *) pName, sizeof ("xglCreateDepthStencilView")))
+        return myTable.CreateDepthStencilView;
+    else if (!strncmp("xglCreateShader", (const char *) pName, sizeof ("xglCreateShader")))
+        return myTable.CreateShader;
+    else if (!strncmp("xglCreateGraphicsPipeline", (const char *) pName, sizeof ("xglCreateGraphicsPipeline")))
+        return myTable.CreateGraphicsPipeline;
+    else if (!strncmp("xglCreateComputePipeline", (const char *) pName, sizeof ("xglCreateComputePipeline")))
+        return myTable.CreateComputePipeline;
+    else if (!strncmp("xglStorePipeline", (const char *) pName, sizeof ("xglStorePipeline")))
+        return myTable.StorePipeline;
+    else if (!strncmp("xglLoadPipeline", (const char *) pName, sizeof ("xglLoadPipeline")))
+        return myTable.LoadPipeline;
+    else if (!strncmp("xglCreatePipelineDelta", (const char *) pName, sizeof ("xglCreatePipelineDelta")))
+        return myTable.CreatePipelineDelta;
+    else if (!strncmp("xglCreateSampler", (const char *) pName, sizeof ("xglCreateSampler")))
+        return myTable.CreateSampler;
+    else if (!strncmp("xglCreateDescriptorSet", (const char *) pName, sizeof ("xglCreateDescriptorSet")))
+        return myTable.CreateDescriptorSet;
+    else if (!strncmp("xglBeginDescriptorSetUpdate", (const char *) pName, sizeof ("xglBeginDescriptorSetUpdate")))
+        return myTable.BeginDescriptorSetUpdate;
+    else if (!strncmp("xglEndDescriptorSetUpdate", (const char *) pName, sizeof ("xglEndDescriptorSetUpdate")))
+        return myTable.EndDescriptorSetUpdate;
+    else if (!strncmp("xglAttachSamplerDescriptors", (const char *) pName, sizeof ("xglAttachSamplerDescriptors")))
+        return myTable.AttachSamplerDescriptors;
+    else if (!strncmp("xglAttachImageViewDescriptors", (const char *) pName, sizeof ("xglAttachImageViewDescriptors")))
+        return myTable.AttachImageViewDescriptors;
+    else if (!strncmp("xglAttachMemoryViewDescriptors", (const char *) pName, sizeof ("xglAttachMemoryViewDescriptors")))
+        return myTable.AttachMemoryViewDescriptors;
+    else if (!strncmp("xglAttachNestedDescriptors", (const char *) pName, sizeof ("xglAttachNestedDescriptors")))
+        return myTable.AttachNestedDescriptors;
+    else if (!strncmp("xglClearDescriptorSetSlots", (const char *) pName, sizeof ("xglClearDescriptorSetSlots")))
+        return myTable.ClearDescriptorSetSlots;
+    else if (!strncmp("xglCreateViewportState", (const char *) pName, sizeof ("xglCreateViewportState")))
+        return myTable.CreateViewportState;
+    else if (!strncmp("xglCreateRasterState", (const char *) pName, sizeof ("xglCreateRasterState")))
+        return myTable.CreateRasterState;
+    else if (!strncmp("xglCreateMsaaState", (const char *) pName, sizeof ("xglCreateMsaaState")))
+        return myTable.CreateMsaaState;
+    else if (!strncmp("xglCreateColorBlendState", (const char *) pName, sizeof ("xglCreateColorBlendState")))
+        return myTable.CreateColorBlendState;
+    else if (!strncmp("xglCreateDepthStencilState", (const char *) pName, sizeof ("xglCreateDepthStencilState")))
+        return myTable.CreateDepthStencilState;
+    else if (!strncmp("xglCreateCommandBuffer", (const char *) pName, sizeof ("xglCreateCommandBuffer")))
+        return myTable.CreateCommandBuffer;
+    else if (!strncmp("xglBeginCommandBuffer", (const char *) pName, sizeof ("xglBeginCommandBuffer")))
+        return myTable.BeginCommandBuffer;
+    else if (!strncmp("xglEndCommandBuffer", (const char *) pName, sizeof ("xglEndCommandBuffer")))
+        return myTable.EndCommandBuffer;
+    else if (!strncmp("xglResetCommandBuffer", (const char *) pName, sizeof ("xglResetCommandBuffer")))
+        return myTable.ResetCommandBuffer;
+    else if (!strncmp("xglCmdBindPipeline", (const char *) pName, sizeof ("xglCmdBindPipeline")))
+        return myTable.CmdBindPipeline;
+    else if (!strncmp("xglCmdBindPipelineDelta", (const char *) pName, sizeof ("xglCmdBindPipelineDelta")))
+        return myTable.CmdBindPipelineDelta;
+    else if (!strncmp("xglCmdBindStateObject", (const char *) pName, sizeof ("xglCmdBindStateObject")))
+        return myTable.CmdBindStateObject;
+    else if (!strncmp("xglCmdBindDescriptorSet", (const char *) pName, sizeof ("xglCmdBindDescriptorSet")))
+        return myTable.CmdBindDescriptorSet;
+    else if (!strncmp("xglCmdBindDynamicMemoryView", (const char *) pName, sizeof ("xglCmdBindDynamicMemoryView")))
+        return myTable.CmdBindDynamicMemoryView;
+    else if (!strncmp("xglCmdBindIndexData", (const char *) pName, sizeof ("xglCmdBindIndexData")))
+        return myTable.CmdBindIndexData;
+    else if (!strncmp("xglCmdBindAttachments", (const char *) pName, sizeof ("xglCmdBindAttachments")))
+        return myTable.CmdBindAttachments;
+    else if (!strncmp("xglCmdPrepareMemoryRegions", (const char *) pName, sizeof ("xglCmdPrepareMemoryRegions")))
+        return myTable.CmdPrepareMemoryRegions;
+    else if (!strncmp("xglCmdPrepareImages", (const char *) pName, sizeof ("xglCmdPrepareImages")))
+        return myTable.CmdPrepareImages;
+    else if (!strncmp("xglCmdDraw", (const char *) pName, sizeof ("xglCmdDraw")))
+        return myTable.CmdDraw;
+    else if (!strncmp("xglCmdDrawIndexed", (const char *) pName, sizeof ("xglCmdDrawIndexed")))
+        return myTable.CmdDrawIndexed;
+    else if (!strncmp("xglCmdDrawIndirect", (const char *) pName, sizeof ("xglCmdDrawIndirect")))
+        return myTable.CmdDrawIndirect;
+    else if (!strncmp("xglCmdDrawIndexedIndirect", (const char *) pName, sizeof ("xglCmdDrawIndexedIndirect")))
+        return myTable.CmdDrawIndexedIndirect;
+    else if (!strncmp("xglCmdDispatch", (const char *) pName, sizeof ("xglCmdDispatch")))
+        return myTable.CmdDispatch;
+    else if (!strncmp("xglCmdDispatchIndirect", (const char *) pName, sizeof ("xglCmdDispatchIndirect")))
+        return myTable.CmdDispatchIndirect;
+    else if (!strncmp("xglCmdCopyMemory", (const char *) pName, sizeof ("xglCmdCopyMemory")))
+        return myTable.CmdCopyMemory;
+    else if (!strncmp("xglCmdCopyImage", (const char *) pName, sizeof ("xglCmdCopyImage")))
+        return myTable.CmdCopyImage;
+    else if (!strncmp("xglCmdCopyMemoryToImage", (const char *) pName, sizeof ("xglCmdCopyMemoryToImage")))
+        return myTable.CmdCopyMemoryToImage;
+    else if (!strncmp("xglCmdCopyImageToMemory", (const char *) pName, sizeof ("xglCmdCopyImageToMemory")))
+        return myTable.CmdCopyImageToMemory;
+    else if (!strncmp("xglCmdCloneImageData", (const char *) pName, sizeof ("xglCmdCloneImageData")))
+        return myTable.CmdCloneImageData;
+    else if (!strncmp("xglCmdUpdateMemory", (const char *) pName, sizeof ("xglCmdUpdateMemory")))
+        return myTable.CmdUpdateMemory;
+    else if (!strncmp("xglCmdFillMemory", (const char *) pName, sizeof ("xglCmdFillMemory")))
+        return myTable.CmdFillMemory;
+    else if (!strncmp("xglCmdClearColorImage", (const char *) pName, sizeof ("xglCmdClearColorImage")))
+        return myTable.CmdClearColorImage;
+    else if (!strncmp("xglCmdClearColorImageRaw", (const char *) pName, sizeof ("xglCmdClearColorImageRaw")))
+        return myTable.CmdClearColorImageRaw;
+    else if (!strncmp("xglCmdClearDepthStencil", (const char *) pName, sizeof ("xglCmdClearDepthStencil")))
+        return myTable.CmdClearDepthStencil;
+    else if (!strncmp("xglCmdResolveImage", (const char *) pName, sizeof ("xglCmdResolveImage")))
+        return myTable.CmdResolveImage;
+    else if (!strncmp("xglCmdSetEvent", (const char *) pName, sizeof ("xglCmdSetEvent")))
+        return myTable.CmdSetEvent;
+    else if (!strncmp("xglCmdResetEvent", (const char *) pName, sizeof ("xglCmdResetEvent")))
+        return myTable.CmdResetEvent;
+    else if (!strncmp("xglCmdMemoryAtomic", (const char *) pName, sizeof ("xglCmdMemoryAtomic")))
+        return myTable.CmdMemoryAtomic;
+    else if (!strncmp("xglCmdBeginQuery", (const char *) pName, sizeof ("xglCmdBeginQuery")))
+        return myTable.CmdBeginQuery;
+    else if (!strncmp("xglCmdEndQuery", (const char *) pName, sizeof ("xglCmdEndQuery")))
+        return myTable.CmdEndQuery;
+    else if (!strncmp("xglCmdResetQueryPool", (const char *) pName, sizeof ("xglCmdResetQueryPool")))
+        return myTable.CmdResetQueryPool;
+    else if (!strncmp("xglCmdWriteTimestamp", (const char *) pName, sizeof ("xglCmdWriteTimestamp")))
+        return myTable.CmdWriteTimestamp;
+    else if (!strncmp("xglCmdInitAtomicCounters", (const char *) pName, sizeof ("xglCmdInitAtomicCounters")))
+        return myTable.CmdInitAtomicCounters;
+    else if (!strncmp("xglCmdLoadAtomicCounters", (const char *) pName, sizeof ("xglCmdLoadAtomicCounters")))
+        return myTable.CmdLoadAtomicCounters;
+    else if (!strncmp("xglCmdSaveAtomicCounters", (const char *) pName, sizeof ("xglCmdSaveAtomicCounters")))
+        return myTable.CmdSaveAtomicCounters;
+    else if (!strncmp("xglDbgSetValidationLevel", (const char *) pName, sizeof ("xglDbgSetValidationLevel")))
+        return myTable.DbgSetValidationLevel;
+	else if (!strncmp("xglDbgRegisterMsgCallback", (const char *) pName, sizeof ("xglDbgRegisterMsgCallback")))
+        return myTable.DbgRegisterMsgCallback;
+	else if (!strncmp("xglDbgUnregisterMsgCallback", (const char *) pName, sizeof ("xglDbgUnregisterMsgCallback")))
+        return myTable.DbgUnregisterMsgCallback;
+    else if (!strncmp("xglDbgSetMessageFilter", (const char *) pName, sizeof ("xglDbgSetMessageFilter")))
+        return myTable.DbgSetMessageFilter;
+    else if (!strncmp("xglDbgSetObjectTag", (const char *) pName, sizeof ("xglDbgSetObjectTag")))
+        return myTable.DbgSetObjectTag;
+    else if (!strncmp("xglDbgSetGlobalOption", (const char *) pName, sizeof ("xglDbgSetGlobalOption")))
+        return myTable.DbgSetGlobalOption;
+    else if (!strncmp("xglDbgSetDeviceOption", (const char *) pName, sizeof ("xglDbgSetDeviceOption")))
+        return myTable.DbgSetDeviceOption;
+    else if (!strncmp("xglCmdDbgMarkerBegin", (const char *) pName, sizeof ("xglCmdDbgMarkerBegin")))
+        return myTable.CmdDbgMarkerBegin;
+    else if (!strncmp("xglCmdDbgMarkerEnd", (const char *) pName, sizeof ("xglCmdDbgMarkerEnd")))
+        return myTable.CmdDbgMarkerEnd;
+    else if (!strncmp("xglWsiX11AssociateConnection", (const char *) pName, sizeof("xglWsiX11AssociateConnection")))
+        return myTable.WsiX11AssociateConnection;
+    else if (!strncmp("xglWsiX11GetMSC", (const char *) pName, sizeof("xglWsiX11GetMSC")))
+        return myTable.WsiX11GetMSC;
+    else if (!strncmp("xglWsiX11CreatePresentableImage", (const char *) pName, sizeof("xglWsiX11CreatePresentableImage")))
+        return myTable.WsiX11CreatePresentableImage;
+    else if (!strncmp("xglWsiX11QueuePresent", (const char *) pName, sizeof("xglWsiX11QueuePresent")))
+        return myTable.WsiX11QueuePresent;
+    else {
+        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        if (gpuw->pGPA == NULL)
+            return NULL;
+        return gpuw->pGPA(gpuw->nextObject, pName);
+    }
+
+}
+
diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt
index 8c01a604..f3486978 100644
--- a/loader/CMakeLists.txt
+++ b/loader/CMakeLists.txt
@@ -1,8 +1,13 @@
-add_custom_command(OUTPUT dispatch.c
+add_custom_command(OUTPUT dispatch.c ${PROJECT_SOURCE_DIR}/icd/common/icd-dispatch-table.h
 	COMMAND ${PROJECT_SOURCE_DIR}/xgl-generate.py loader > dispatch.c
+        COMMAND ${PROJECT_SOURCE_DIR}/xgl-generate.py icd-dispatch-table > ${PROJECT_SOURCE_DIR}/icd/common/icd-dispatch-table.h
 	           DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py
 	                   ${PROJECT_SOURCE_DIR}/xgl.py)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+include_directories(
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${CMAKE_CURRENT_BINARY_DIR}
+)
 
 add_library(XGL SHARED loader.c dispatch.c)
 set_target_properties(XGL PROPERTIES SOVERSION 0)
diff --git a/loader/loader.c b/loader/loader.c
index fddbc24f..c86ada21 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -37,25 +37,27 @@
 #include <unistd.h>
 #include <dlfcn.h>
 #include <pthread.h>
-
+#include <assert.h>
 #include "loader.h"
 
-typedef XGL_RESULT (XGLAPI *InitAndEnumerateGpusT)(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb, XGL_UINT maxGpus, XGL_UINT* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
-typedef XGL_RESULT (XGLAPI *DbgRegisterMsgCallbackT)(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, XGL_VOID* pUserData);
-typedef XGL_RESULT (XGLAPI *DbgUnregisterMsgCallbackT)(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
-typedef XGL_RESULT (XGLAPI *DbgSetGlobalOptionT)(XGL_INT dbgOption, XGL_SIZE dataSize, const XGL_VOID* pData);
 
 struct loader_icd {
     void *handle;
 
-    InitAndEnumerateGpusT InitAndEnumerateGpus;
-    DbgRegisterMsgCallbackT DbgRegisterMsgCallback;
-    DbgUnregisterMsgCallbackT DbgUnregisterMsgCallback;
-    DbgSetGlobalOptionT DbgSetGlobalOption;
+    GetProcAddrType GetProcAddr;
+    InitAndEnumerateGpusType InitAndEnumerateGpus;
+    DbgRegisterMsgCallbackType DbgRegisterMsgCallback;
+    DbgUnregisterMsgCallbackType DbgUnregisterMsgCallback;
+    DbgSetGlobalOptionType DbgSetGlobalOption;
 
     struct loader_icd *next;
 };
 
+struct loader_layers {
+    void *lib_handle;
+    char lib_name[1024];
+};
+
 struct loader_msg_callback {
     XGL_DBG_MSG_CALLBACK_FUNCTION func;
     XGL_VOID *data;
@@ -63,10 +65,15 @@ struct loader_msg_callback {
     struct loader_msg_callback *next;
 };
 
+
 static struct {
     bool scanned;
     struct loader_icd *icds;
-
+    XGL_LAYER_DISPATCH_TABLE *loader_dispatch;
+    XGL_UINT layer_count;
+    bool layer_scaned;
+    char layer_dirs[4096];
+    struct loader_layers layer_libs[MAX_LAYER_LIBRARIES];
     struct loader_msg_callback *msg_callbacks;
 
     bool debug_echo_enable;
@@ -198,13 +205,14 @@ loader_icd_create(const char *filename)
     }
 
 #define LOOKUP(icd, func) do {                              \
-    icd->func = (func## T) dlsym(icd->handle, "xgl" #func); \
+    icd->func = (func## Type) dlsym(icd->handle, "xgl" #func); \
     if (!icd->func) {                                       \
         loader_log(XGL_DBG_MSG_WARNING, 0, dlerror());      \
         loader_icd_destroy(icd);                            \
         return NULL;                                        \
     }                                                       \
 } while (0)
+    LOOKUP(icd, GetProcAddr);
     LOOKUP(icd, InitAndEnumerateGpus);
     LOOKUP(icd, DbgRegisterMsgCallback);
     LOOKUP(icd, DbgUnregisterMsgCallback);
@@ -351,6 +359,603 @@ static void loader_icd_scan(void)
     loader.scanned = true;
 }
 
+#ifndef DEFAULT_XGL_LAYERS_PATH
+// TODO: Is this a good default locations
+#define DEFAULT_XGL_LAYERS_PATH ".:/usr/lib/i386-linux-gnu/xgl:/usr/lib/x86_64-linux-gnu/xgl"
+#endif
+
+static void layer_lib_scan(const char * libInPaths, const bool useDefaultDirs, const bool openLibs)
+{
+    const char *p, *next;
+    char *libPaths = &loader.layer_dirs[0];
+    DIR *curdir;
+    struct dirent *dent;
+    int len, i, n;
+
+    if (libInPaths){
+        strncpy(libPaths, libInPaths, sizeof(loader.layer_dirs));
+    }
+    else {
+        *libPaths = '\0';
+    }
+
+    /* cleanup any previously scanned libraries */
+    for (i = 0; i < loader.layer_count; i++) {
+        if (loader.layer_libs[i].lib_handle != NULL)
+            dlclose(loader.layer_libs[i].lib_handle);
+        loader.layer_libs[i].lib_handle = NULL;
+    }
+    loader.layer_count = 0;
+
+    if (useDefaultDirs)
+       strncat(libPaths, DEFAULT_XGL_LAYERS_PATH, sizeof(loader.layer_dirs) - sizeof(DEFAULT_XGL_LAYERS_PATH));
+
+    for (p = libPaths; *p; p = next) {
+       next = strchr(p, ':');
+       if (next == NULL) {
+          len = strlen(p);
+          next = p + len;
+       }
+       else {
+          len = next - p;
+          *(char *) next = '\0';
+          next++;
+       }
+
+       curdir = opendir(p);
+       if (curdir) {
+          dent = readdir(curdir);
+          while (dent) {
+              n = loader.layer_count;
+             /* look for wrappers starting with "libXGLlayer" */
+             if (!strncmp(dent->d_name, "libXGLLayer", strlen("libXGLLayer"))) {
+                snprintf((char *) &(loader.layer_libs[n].lib_name), sizeof(loader.layer_libs[0].lib_name), "%s/%s",p,dent->d_name);
+                if ((loader.layer_libs[n].lib_handle = dlopen((const char *) &(loader.layer_libs[n].lib_name), RTLD_LAZY)) == NULL)
+                    continue;
+
+                loader.layer_count++;
+                if (!openLibs)
+                    dlclose(loader.layer_libs[n].lib_handle);
+             }
+
+             dent = readdir(curdir);
+          }
+          closedir(curdir);
+       }
+    }
+
+    loader.layer_scaned = true;
+}
+
+#if 0
+static bool layer_lib_sort(char * str, const XGL_UINT count)
+{
+    XGL_UINT i;
+    struct loader_layers temp, *cur, *start;
+
+    start = &loader.layer_libs[count];
+    for (i = count; i < loader.layer_count; i++) {
+        cur = &loader.layer_libs[i];
+
+        if (!strcmp(str, cur->lib_name) && cur->lib_handle != NULL) {
+            if (count == i)
+                return true;
+            strcpy(temp.lib_name, cur->lib_name);
+            temp.lib_handle = cur->lib_handle;
+            strcpy(cur->lib_name, start->lib_name);
+            cur->lib_handle = start->lib_handle;
+            strcpy(start->lib_name, temp.lib_name);
+            start->lib_handle = temp.lib_handle;
+            return true;
+        }
+    }
+    return false;
+}
+#endif
+LOADER_EXPORT XGL_RESULT XGLAPI ScanForLayers(const XGL_CHAR* pLibraryDirectories, XGL_CHAR * pStr)
+{
+    size_t size = 0;
+    XGL_UINT i;
+    static XGL_CHAR *lib_str=NULL;
+
+    if (!pLibraryDirectories)
+        return XGL_ERROR_INVALID_POINTER;
+
+    if (strlen((const char *) pLibraryDirectories) > sizeof(loader.layer_dirs))
+        return XGL_ERROR_INVALID_POINTER;
+
+    layer_lib_scan((const char *) pLibraryDirectories, true, false);
+
+    for (i = 0; i < loader.layer_count; i++) {
+        size += strlen(loader.layer_libs[i].lib_name) + 1;
+    }
+
+    free(lib_str);
+    lib_str = malloc(size);
+    if (!lib_str)
+        return XGL_ERROR_OUT_OF_MEMORY;
+
+   pStr = lib_str;
+   for (i = 0; i < loader.layer_count; i++) {
+        strncat((char *) pStr, loader.layer_libs[i].lib_name, strlen(loader.layer_libs[i].lib_name));
+        strcat((char *) pStr, ":");
+    }
+    return XGL_SUCCESS;
+}
+
+static void init_dispatch_table(XGL_LAYER_DISPATCH_TABLE *tab, GetProcAddrType fpGPA, XGL_PHYSICAL_GPU gpu)
+{
+    tab->GetProcAddr = fpGPA;
+    tab->InitAndEnumerateGpus = fpGPA(gpu, (const XGL_CHAR *) "xglInitAndEnumerateGpus");
+    tab->GetGpuInfo = fpGPA(gpu, (const XGL_CHAR *) "xglGetGpuInfo");
+    tab->CreateDevice = fpGPA(gpu, (const XGL_CHAR *) "xglCreateDevice");
+    tab->DestroyDevice = fpGPA(gpu, (const XGL_CHAR *) "xglDestroyDevice");
+    tab->GetExtensionSupport = fpGPA(gpu, (const XGL_CHAR *) "xglGetExtensionSupport");
+    tab->GetDeviceQueue = fpGPA(gpu, (const XGL_CHAR *) "xglGetDeviceQueue");
+    tab->QueueSubmit = fpGPA(gpu, (const XGL_CHAR *) "xglQueueSubmit");
+    tab->QueueSetGlobalMemReferences = fpGPA(gpu, (const XGL_CHAR *) "xglQueueSetGlobalMemReferences");
+    tab->QueueWaitIdle = fpGPA(gpu, (const XGL_CHAR *) "xglQueueWaitIdle");
+    tab->DeviceWaitIdle = fpGPA(gpu, (const XGL_CHAR *) "xglDeviceWaitIdle");
+    tab->GetMemoryHeapCount = fpGPA(gpu, (const XGL_CHAR *) "xglGetMemoryHeapCount");
+    tab->GetMemoryHeapInfo = fpGPA(gpu, (const XGL_CHAR *) "xglGetMemoryHeapInfo");
+    tab->AllocMemory = fpGPA(gpu, (const XGL_CHAR *) "xglAllocMemory");
+    tab->FreeMemory = fpGPA(gpu, (const XGL_CHAR *) "xglFreeMemory");
+    tab->SetMemoryPriority = fpGPA(gpu, (const XGL_CHAR *) "xglSetMemoryPriority");
+    tab->MapMemory = fpGPA(gpu, (const XGL_CHAR *) "xglMapMemory");
+    tab->UnmapMemory = fpGPA(gpu, (const XGL_CHAR *) "xglUnmapMemory");
+    tab->PinSystemMemory = fpGPA(gpu, (const XGL_CHAR *) "xglPinSystemMemory");
+    tab->RemapVirtualMemoryPages = fpGPA(gpu, (const XGL_CHAR *) "xglRemapVirtualMemoryPages");
+    tab->GetMultiGpuCompatibility = fpGPA(gpu, (const XGL_CHAR *) "xglGetMultiGpuCompatibility");
+    tab->OpenSharedMemory = fpGPA(gpu, (const XGL_CHAR *) "xglOpenSharedMemory");
+    tab->OpenSharedQueueSemaphore = fpGPA(gpu, (const XGL_CHAR *) "xglOpenSharedQueueSemaphore");
+    tab->OpenPeerMemory = fpGPA(gpu, (const XGL_CHAR *) "xglOpenPeerMemory");
+    tab->OpenPeerImage = fpGPA(gpu, (const XGL_CHAR *) "xglOpenPeerImage");
+    tab->DestroyObject = fpGPA(gpu, (const XGL_CHAR *) "xglDestroyObject");
+    tab->GetObjectInfo = fpGPA(gpu, (const XGL_CHAR *) "xglGetObjectInfo");
+    tab->BindObjectMemory = fpGPA(gpu, (const XGL_CHAR *) "xglBindObjectMemory");
+    tab->CreateFence = fpGPA(gpu, (const XGL_CHAR *) "xglCreateFence");
+    tab->GetFenceStatus = fpGPA(gpu, (const XGL_CHAR *) "xglGetFenceStatus");
+    tab->WaitForFences = fpGPA(gpu, (const XGL_CHAR *) "xglWaitForFences");
+    tab->CreateQueueSemaphore = fpGPA(gpu, (const XGL_CHAR *) "xglCreateQueueSemaphore");
+    tab->SignalQueueSemaphore = fpGPA(gpu, (const XGL_CHAR *) "xglSignalQueueSemaphore");
+    tab->WaitQueueSemaphore = fpGPA(gpu, (const XGL_CHAR *) "xglWaitQueueSemaphore");
+    tab->CreateEvent = fpGPA(gpu, (const XGL_CHAR *) "xglCreateEvent");
+    tab->GetEventStatus = fpGPA(gpu, (const XGL_CHAR *) "xglGetEventStatus");
+    tab->SetEvent = fpGPA(gpu, (const XGL_CHAR *) "xglSetEvent");
+    tab->ResetEvent = fpGPA(gpu, (const XGL_CHAR *) "xglResetEvent");
+    tab->CreateQueryPool = fpGPA(gpu, (const XGL_CHAR *) "xglCreateQueryPool");
+    tab->GetQueryPoolResults = fpGPA(gpu, (const XGL_CHAR *) "xglGetQueryPoolResults");
+    tab->GetFormatInfo = fpGPA(gpu, (const XGL_CHAR *) "xglGetFormatInfo");
+    tab->CreateImage = fpGPA(gpu, (const XGL_CHAR *) "xglCreateImage");
+    tab->GetImageSubresourceInfo = fpGPA(gpu, (const XGL_CHAR *) "xglGetImageSubresourceInfo");
+    tab->CreateImageView = fpGPA(gpu, (const XGL_CHAR *) "xglCreateImageView");
+    tab->CreateColorAttachmentView = fpGPA(gpu, (const XGL_CHAR *) "xglCreateColorAttachmentView");
+    tab->CreateDepthStencilView = fpGPA(gpu, (const XGL_CHAR *) "xglCreateDepthStencilView");
+    tab->CreateShader = fpGPA(gpu, (const XGL_CHAR *) "xglCreateShader");
+    tab->CreateGraphicsPipeline = fpGPA(gpu, (const XGL_CHAR *) "xglCreateGraphicsPipeline");
+    tab->CreateComputePipeline = fpGPA(gpu, (const XGL_CHAR *) "xglCreateComputePipeline");
+    tab->StorePipeline = fpGPA(gpu, (const XGL_CHAR *) "xglStorePipeline");
+    tab->LoadPipeline = fpGPA(gpu, (const XGL_CHAR *) "xglLoadPipeline");
+    tab->CreatePipelineDelta = fpGPA(gpu, (const XGL_CHAR *) "xglCreatePipelineDelta");
+    tab->CreateSampler = fpGPA(gpu, (const XGL_CHAR *) "xglCreateSampler");
+    tab->CreateDescriptorSet = fpGPA(gpu, (const XGL_CHAR *) "xglCreateDescriptorSet");
+    tab->BeginDescriptorSetUpdate = fpGPA(gpu, (const XGL_CHAR *) "xglBeginDescriptorSetUpdate");
+    tab->EndDescriptorSetUpdate = fpGPA(gpu, (const XGL_CHAR *) "xglEndDescriptorSetUpdate");
+    tab->AttachSamplerDescriptors = fpGPA(gpu, (const XGL_CHAR *) "xglAttachSamplerDescriptors");
+    tab->AttachImageViewDescriptors = fpGPA(gpu, (const XGL_CHAR *) "xglAttachImageViewDescriptors");
+    tab->AttachMemoryViewDescriptors = fpGPA(gpu, (const XGL_CHAR *) "xglAttachMemoryViewDescriptors");
+    tab->AttachNestedDescriptors = fpGPA(gpu, (const XGL_CHAR *) "xglAttachNestedDescriptors");
+    tab->ClearDescriptorSetSlots = fpGPA(gpu, (const XGL_CHAR *) "xglClearDescriptorSetSlots");
+    tab->CreateViewportState = fpGPA(gpu, (const XGL_CHAR *) "xglCreateViewportState");
+    tab->CreateRasterState = fpGPA(gpu, (const XGL_CHAR *) "xglCreateRasterState");
+    tab->CreateMsaaState = fpGPA(gpu, (const XGL_CHAR *) "xglCreateMsaaState");
+    tab->CreateColorBlendState = fpGPA(gpu, (const XGL_CHAR *) "xglCreateColorBlendState");
+    tab->CreateDepthStencilState = fpGPA(gpu, (const XGL_CHAR *) "xglCreateDepthStencilState");
+    tab->CreateCommandBuffer = fpGPA(gpu, (const XGL_CHAR *) "xglCreateCommandBuffer");
+    tab->BeginCommandBuffer = fpGPA(gpu, (const XGL_CHAR *) "xglBeginCommandBuffer");
+    tab->EndCommandBuffer = fpGPA(gpu, (const XGL_CHAR *) "xglEndCommandBuffer");
+    tab->ResetCommandBuffer = fpGPA(gpu, (const XGL_CHAR *) "xglResetCommandBuffer");
+    tab->CmdBindPipeline = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindPipeline");
+    tab->CmdBindPipelineDelta = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindPipelineDelta");
+    tab->CmdBindStateObject = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindStateObject");
+    tab->CmdBindDescriptorSet = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindDescriptorSet");
+    tab->CmdBindDynamicMemoryView = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindDynamicMemoryView");
+    tab->CmdBindIndexData = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindIndexData");
+    tab->CmdBindAttachments = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBindAttachments");
+    tab->CmdPrepareMemoryRegions = fpGPA(gpu, (const XGL_CHAR *) "xglCmdPrepareMemoryRegions");
+    tab->CmdPrepareImages = fpGPA(gpu, (const XGL_CHAR *) "xglCmdPrepareImages");
+    tab->CmdDraw = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDraw");
+    tab->CmdDrawIndexed = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDrawIndexed");
+    tab->CmdDrawIndirect = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDrawIndirect");
+    tab->CmdDrawIndexedIndirect = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDrawIndexedIndirect");
+    tab->CmdDispatch = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDispatch");
+    tab->CmdDispatchIndirect = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDispatchIndirect");
+    tab->CmdCopyMemory = fpGPA(gpu, (const XGL_CHAR *) "xglCmdCopyMemory");
+    tab->CmdCopyImage = fpGPA(gpu, (const XGL_CHAR *) "xglCmdCopyImage");
+    tab->CmdCopyMemoryToImage = fpGPA(gpu, (const XGL_CHAR *) "xglCmdCopyMemoryToImage");
+    tab->CmdCopyImageToMemory = fpGPA(gpu, (const XGL_CHAR *) "xglCmdCopyImageToMemory");
+    tab->CmdCloneImageData = fpGPA(gpu, (const XGL_CHAR *) "xglCmdCloneImageData");
+    tab->CmdUpdateMemory = fpGPA(gpu, (const XGL_CHAR *) "xglCmdUpdateMemory");
+    tab->CmdFillMemory = fpGPA(gpu, (const XGL_CHAR *) "xglCmdFillMemory");
+    tab->CmdClearColorImage = fpGPA(gpu, (const XGL_CHAR *) "xglCmdClearColorImage");
+    tab->CmdClearColorImageRaw = fpGPA(gpu, (const XGL_CHAR *) "xglCmdClearColorImageRaw");
+    tab->CmdClearDepthStencil = fpGPA(gpu, (const XGL_CHAR *) "xglCmdClearDepthStencil");
+    tab->CmdResolveImage = fpGPA(gpu, (const XGL_CHAR *) "xglCmdResolveImage");
+    tab->CmdSetEvent = fpGPA(gpu, (const XGL_CHAR *) "xglCmdSetEvent");
+    tab->CmdResetEvent = fpGPA(gpu, (const XGL_CHAR *) "xglCmdResetEvent");
+    tab->CmdMemoryAtomic = fpGPA(gpu, (const XGL_CHAR *) "xglCmdMemoryAtomic");
+    tab->CmdBeginQuery = fpGPA(gpu, (const XGL_CHAR *) "xglCmdBeginQuery");
+    tab->CmdEndQuery = fpGPA(gpu, (const XGL_CHAR *) "xglCmdEndQuery");
+    tab->CmdResetQueryPool = fpGPA(gpu, (const XGL_CHAR *) "xglCmdResetQueryPool");
+    tab->CmdWriteTimestamp = fpGPA(gpu, (const XGL_CHAR *) "xglCmdWriteTimestamp");
+    tab->CmdInitAtomicCounters = fpGPA(gpu, (const XGL_CHAR *) "xglCmdInitAtomicCounters");
+    tab->CmdLoadAtomicCounters = fpGPA(gpu, (const XGL_CHAR *) "xglCmdLoadAtomicCounters");
+    tab->CmdSaveAtomicCounters = fpGPA(gpu, (const XGL_CHAR *) "xglCmdSaveAtomicCounters");
+    tab->DbgSetValidationLevel = fpGPA(gpu, (const XGL_CHAR *) "xglDbgSetValidationLevel");
+    tab->DbgRegisterMsgCallback = fpGPA(gpu, (const XGL_CHAR *) "xglDbgRegisterMsgCallback");
+    tab->DbgUnregisterMsgCallback = fpGPA(gpu, (const XGL_CHAR *) "xglDbgUnregisterMsgCallback");
+    tab->DbgSetMessageFilter = fpGPA(gpu, (const XGL_CHAR *) "xglDbgSetMessageFilter");
+    tab->DbgSetObjectTag = fpGPA(gpu, (const XGL_CHAR *) "xglDbgSetObjectTag");
+    tab->DbgSetGlobalOption = fpGPA(gpu, (const XGL_CHAR *) "xglDbgSetGlobalOption");
+    tab->DbgSetDeviceOption = fpGPA(gpu, (const XGL_CHAR *) "xglDbgSetDeviceOption");
+    tab->CmdDbgMarkerBegin = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDbgMarkerBegin");
+    tab->CmdDbgMarkerEnd = fpGPA(gpu, (const XGL_CHAR *) "xglCmdDbgMarkerEnd");
+    tab->WsiX11AssociateConnection = fpGPA(gpu, (const XGL_CHAR *) "xglWsiX11AssociateConnection");
+    tab->WsiX11GetMSC = fpGPA(gpu, (const XGL_CHAR *) "xglWsiX11GetMSC");
+    tab->WsiX11CreatePresentableImage = fpGPA(gpu, (const XGL_CHAR *) "xglWsiX11CreatePresentableImage");
+    tab->WsiX11QueuePresent = fpGPA(gpu, (const XGL_CHAR *) "xglWsiX11QueuePresent");
+}
+
+extern XGL_UINT ActivateLayers(XGL_PHYSICAL_GPU *gpu)
+{
+    static bool layer_installed = false;
+    //const struct loader_icd *icd;
+    /* activate any layer libraries */
+    if (loader.layer_count > 0 && !layer_installed) {
+
+        //todo get icd from gpu
+        //icd = loader.icds;  // We are only going to configure the first driver
+        //SetDispatchType IcdSetDispatch = dlsym(icd->handle, "xglSetDispatch");
+
+        // TODO For now just assume  all layers scanned will be  activated in the order they were scanned
+        XGL_BASE_LAYER_OBJECT *gpuObj = (XGL_BASE_LAYER_OBJECT *) *gpu;
+        XGL_BASE_LAYER_OBJECT *nextGpuObj;
+        GetProcAddrType nextGPA = gpuObj->pGPA;
+        for (XGL_INT i = loader.layer_count - 1; i >= 0; i--) {
+
+            if ((loader.layer_libs[i].lib_handle = dlopen((const char *) &(loader.layer_libs[i].lib_name), RTLD_LAZY | RTLD_DEEPBIND)) == NULL) {
+                loader_log(XGL_DBG_MSG_ERROR, 0, "Failed to open layer library %s got error %d", loader.layer_libs[i].lib_name, dlerror());
+                continue;
+            } else {
+                loader_log(XGL_DBG_MSG_UNKNOWN, 0, "Inserting layer lib %s",loader.layer_libs[i].lib_name);
+            }
+
+            //create newly wrapped gpu object
+            nextGpuObj = malloc(sizeof(XGL_BASE_LAYER_OBJECT));
+            if (! nextGpuObj)
+                loader_log(XGL_DBG_MSG_ERROR, 0, "Failed to malloc Gpu object for layer");
+            nextGpuObj->pGPA = nextGPA;
+            nextGpuObj->baseObject = gpuObj->baseObject;
+            nextGpuObj->nextObject = gpuObj;
+            gpuObj = nextGpuObj;
+
+            nextGPA = dlsym(loader.layer_libs[i].lib_handle, "xglGetProcAddr");
+            if (!nextGPA) {
+                loader_log(XGL_DBG_MSG_ERROR, 0, "Failed to find xglGetProcAddr in layer %s", loader.layer_libs[i].lib_name);
+                continue;
+            }
+
+            if (i == 0) {
+                //TODO handle multiple icd case
+                init_dispatch_table(loader.loader_dispatch, nextGPA, gpuObj);
+                //IcdSetDispatch(&new_table, true);
+            }
+        }
+        *gpu = ((XGL_PHYSICAL_GPU *) gpuObj);
+        layer_installed = true;
+    }
+    return loader.layer_count;
+}
+
+#if 0
+LOADER_EXPORT XGL_RESULT xglSetLayers(const XGL_CHAR * pStr)
+{
+    char *p, *next, *str;
+    int len;
+    XGL_UINT count= 0;
+
+    if (!pStr)
+        return XGL_ERROR_INVALID_POINTER;
+
+    p= (char *) pStr;
+    str = malloc(strlen(p) + 1);
+    do {
+        next = strchr(p, ':');
+        if (next == NULL) {
+            len = strlen(p);
+            next = p + len;
+        }
+        else {
+            len = next - p;
+            *(char *) next = '\0';
+            next++;
+        }
+
+        strncpy(str, p, len);
+        str[len] = '\0';
+        if (layer_lib_sort(str, count))
+           count++;
+        p = next;
+
+    } while (*p  && count < MAX_LAYER_LIBRARIES-1);
+
+    for (int i = count; i < loader.layer_count; i++) {
+        loader.layer_libs[i].lib_handle = NULL;
+    }
+
+    loader.layer_count = count;
+    free(str);
+
+    return XGL_SUCCESS;
+}
+
+#endif
+
+LOADER_EXPORT void * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const XGL_CHAR * pName) {
+
+    if (gpu == NULL)
+        return NULL;
+
+    XGL_LAYER_DISPATCH_TABLE * disp_table = * (XGL_LAYER_DISPATCH_TABLE **) gpu;
+    if (disp_table == NULL)
+        return NULL;
+
+    if (!strncmp("xglGetProcAddr", (const char *) pName, sizeof("xglGetProcAddr")))
+        return xglGetProcAddr;
+    else if (!strncmp("xglInitAndEnumerateGpus", (const char *) pName, sizeof("xglInitAndEnumerateGpus")))
+        return disp_table->InitAndEnumerateGpus;
+    else if (!strncmp("xglGetGpuInfo", (const char *) pName, sizeof ("xglGetGpuInfo")))
+        return disp_table->GetGpuInfo;
+    else if (!strncmp("xglCreateDevice", (const char *) pName, sizeof ("xglCreateDevice")))
+        return disp_table->CreateDevice;
+    else if (!strncmp("xglDestroyDevice", (const char *) pName, sizeof ("xglDestroyDevice")))
+        return disp_table->DestroyDevice;
+    else if (!strncmp("xglGetExtensionSupport", (const char *) pName, sizeof ("xglGetExtensionSupport")))
+        return disp_table->GetExtensionSupport;
+    else if (!strncmp("xglGetDeviceQueue", (const char *) pName, sizeof ("xglGetDeviceQueue")))
+        return disp_table->GetDeviceQueue;
+    else if (!strncmp("xglQueueSubmit", (const char *) pName, sizeof ("xglQueueSubmit")))
+        return disp_table->QueueSubmit;
+    else if (!strncmp("xglQueueSetGlobalMemReferences", (const char *) pName, sizeof ("xglQueueSetGlobalMemReferences")))
+        return disp_table->QueueSetGlobalMemReferences;
+    else if (!strncmp("xglQueueWaitIdle", (const char *) pName, sizeof ("xglQueueWaitIdle")))
+        return disp_table->QueueWaitIdle;
+    else if (!strncmp("xglDeviceWaitIdle", (const char *) pName, sizeof ("xglDeviceWaitIdle")))
+        return disp_table->DeviceWaitIdle;
+    else if (!strncmp("xglGetMemoryHeapCount", (const char *) pName, sizeof ("xglGetMemoryHeapCount")))
+        return disp_table->GetMemoryHeapCount;
+    else if (!strncmp("xglGetMemoryHeapInfo", (const char *) pName, sizeof ("xglGetMemoryHeapInfo")))
+        return disp_table->GetMemoryHeapInfo;
+    else if (!strncmp("xglAllocMemory", (const char *) pName, sizeof ("xglAllocMemory")))
+        return disp_table->AllocMemory;
+    else if (!strncmp("xglFreeMemory", (const char *) pName, sizeof ("xglFreeMemory")))
+        return disp_table->FreeMemory;
+    else if (!strncmp("xglSetMemoryPriority", (const char *) pName, sizeof ("xglSetMemoryPriority")))
+        return disp_table->SetMemoryPriority;
+    else if (!strncmp("xglMapMemory", (const char *) pName, sizeof ("xglMapMemory")))
+        return disp_table->MapMemory;
+    else if (!strncmp("xglUnmapMemory", (const char *) pName, sizeof ("xglUnmapMemory")))
+        return disp_table->UnmapMemory;
+    else if (!strncmp("xglPinSystemMemory", (const char *) pName, sizeof ("xglPinSystemMemory")))
+        return disp_table->PinSystemMemory;
+    else if (!strncmp("xglRemapVirtualMemoryPages", (const char *) pName, sizeof ("xglRemapVirtualMemoryPages")))
+        return disp_table->RemapVirtualMemoryPages;
+    else if (!strncmp("xglGetMultiGpuCompatibility", (const char *) pName, sizeof ("xglGetMultiGpuCompatibility")))
+        return disp_table->GetMultiGpuCompatibility;
+    else if (!strncmp("xglOpenSharedMemory", (const char *) pName, sizeof ("xglOpenSharedMemory")))
+        return disp_table->OpenSharedMemory;
+    else if (!strncmp("xglOpenSharedQueueSemaphore", (const char *) pName, sizeof ("xglOpenSharedQueueSemaphore")))
+        return disp_table->OpenSharedQueueSemaphore;
+    else if (!strncmp("xglOpenPeerMemory", (const char *) pName, sizeof ("xglOpenPeerMemory")))
+        return disp_table->OpenPeerMemory;
+    else if (!strncmp("xglOpenPeerImage", (const char *) pName, sizeof ("xglOpenPeerImage")))
+        return disp_table->OpenPeerImage;
+    else if (!strncmp("xglDestroyObject", (const char *) pName, sizeof ("xglDestroyObject")))
+        return disp_table->DestroyObject;
+    else if (!strncmp("xglGetObjectInfo", (const char *) pName, sizeof ("xglGetObjectInfo")))
+        return disp_table->GetObjectInfo;
+    else if (!strncmp("xglBindObjectMemory", (const char *) pName, sizeof ("xglBindObjectMemory")))
+        return disp_table->BindObjectMemory;
+    else if (!strncmp("xglCreateFence", (const char *) pName, sizeof ("xgllCreateFence")))
+        return disp_table->CreateFence;
+    else if (!strncmp("xglGetFenceStatus", (const char *) pName, sizeof ("xglGetFenceStatus")))
+        return disp_table->GetFenceStatus;
+    else if (!strncmp("xglWaitForFences", (const char *) pName, sizeof ("xglWaitForFences")))
+        return disp_table->WaitForFences;
+    else if (!strncmp("xglCreateQueueSemaphore", (const char *) pName, sizeof ("xgllCreateQueueSemaphore")))
+        return disp_table->CreateQueueSemaphore;
+    else if (!strncmp("xglSignalQueueSemaphore", (const char *) pName, sizeof ("xglSignalQueueSemaphore")))
+        return disp_table->SignalQueueSemaphore;
+    else if (!strncmp("xglWaitQueueSemaphore", (const char *) pName, sizeof ("xglWaitQueueSemaphore")))
+        return disp_table->WaitQueueSemaphore;
+    else if (!strncmp("xglCreateEvent", (const char *) pName, sizeof ("xgllCreateEvent")))
+        return disp_table->CreateEvent;
+    else if (!strncmp("xglGetEventStatus", (const char *) pName, sizeof ("xglGetEventStatus")))
+        return disp_table->GetEventStatus;
+    else if (!strncmp("xglSetEvent", (const char *) pName, sizeof ("xglSetEvent")))
+        return disp_table->SetEvent;
+    else if (!strncmp("xglResetEvent", (const char *) pName, sizeof ("xgllResetEvent")))
+        return disp_table->ResetEvent;
+    else if (!strncmp("xglCreateQueryPool", (const char *) pName, sizeof ("xglCreateQueryPool")))
+        return disp_table->CreateQueryPool;
+    else if (!strncmp("xglGetQueryPoolResults", (const char *) pName, sizeof ("xglGetQueryPoolResults")))
+        return disp_table->GetQueryPoolResults;
+    else if (!strncmp("xglGetFormatInfo", (const char *) pName, sizeof ("xglGetFormatInfo")))
+        return disp_table->GetFormatInfo;
+    else if (!strncmp("xglCreateImage", (const char *) pName, sizeof ("xglCreateImage")))
+        return disp_table->CreateImage;
+    else if (!strncmp("xglGetImageSubresourceInfo", (const char *) pName, sizeof ("xglGetImageSubresourceInfo")))
+        return disp_table->GetImageSubresourceInfo;
+    else if (!strncmp("xglCreateImageView", (const char *) pName, sizeof ("xglCreateImageView")))
+        return disp_table->CreateImageView;
+    else if (!strncmp("xglCreateColorAttachmentView", (const char *) pName, sizeof ("xglCreateColorAttachmentView")))
+        return disp_table->CreateColorAttachmentView;
+    else if (!strncmp("xglCreateDepthStencilView", (const char *) pName, sizeof ("xglCreateDepthStencilView")))
+        return disp_table->CreateDepthStencilView;
+    else if (!strncmp("xglCreateShader", (const char *) pName, sizeof ("xglCreateShader")))
+        return disp_table->CreateShader;
+    else if (!strncmp("xglCreateGraphicsPipeline", (const char *) pName, sizeof ("xglCreateGraphicsPipeline")))
+        return disp_table->CreateGraphicsPipeline;
+    else if (!strncmp("xglCreateComputePipeline", (const char *) pName, sizeof ("xglCreateComputePipeline")))
+        return disp_table->CreateComputePipeline;
+    else if (!strncmp("xglStorePipeline", (const char *) pName, sizeof ("xglStorePipeline")))
+        return disp_table->StorePipeline;
+    else if (!strncmp("xglLoadPipeline", (const char *) pName, sizeof ("xglLoadPipeline")))
+        return disp_table->LoadPipeline;
+    else if (!strncmp("xglCreatePipelineDelta", (const char *) pName, sizeof ("xglCreatePipelineDelta")))
+        return disp_table->CreatePipelineDelta;
+    else if (!strncmp("xglCreateSampler", (const char *) pName, sizeof ("xglCreateSampler")))
+        return disp_table->CreateSampler;
+    else if (!strncmp("xglCreateDescriptorSet", (const char *) pName, sizeof ("xglCreateDescriptorSet")))
+        return disp_table->CreateDescriptorSet;
+    else if (!strncmp("xglBeginDescriptorSetUpdate", (const char *) pName, sizeof ("xglBeginDescriptorSetUpdate")))
+        return disp_table->BeginDescriptorSetUpdate;
+    else if (!strncmp("xglEndDescriptorSetUpdate", (const char *) pName, sizeof ("xglEndDescriptorSetUpdate")))
+        return disp_table->EndDescriptorSetUpdate;
+    else if (!strncmp("xglAttachSamplerDescriptors", (const char *) pName, sizeof ("xglAttachSamplerDescriptors")))
+        return disp_table->AttachSamplerDescriptors;
+    else if (!strncmp("xglAttachImageViewDescriptors", (const char *) pName, sizeof ("xglAttachImageViewDescriptors")))
+        return disp_table->AttachImageViewDescriptors;
+    else if (!strncmp("xglAttachMemoryViewDescriptors", (const char *) pName, sizeof ("xglAttachMemoryViewDescriptors")))
+        return disp_table->AttachMemoryViewDescriptors;
+    else if (!strncmp("xglAttachNestedDescriptors", (const char *) pName, sizeof ("xglAttachNestedDescriptors")))
+        return disp_table->AttachNestedDescriptors;
+    else if (!strncmp("xglClearDescriptorSetSlots", (const char *) pName, sizeof ("xglClearDescriptorSetSlots")))
+        return disp_table->ClearDescriptorSetSlots;
+    else if (!strncmp("xglCreateViewportState", (const char *) pName, sizeof ("xglCreateViewportState")))
+        return disp_table->CreateViewportState;
+    else if (!strncmp("xglCreateRasterState", (const char *) pName, sizeof ("xglCreateRasterState")))
+        return disp_table->CreateRasterState;
+    else if (!strncmp("xglCreateMsaaState", (const char *) pName, sizeof ("xglCreateMsaaState")))
+        return disp_table->CreateMsaaState;
+    else if (!strncmp("xglCreateColorBlendState", (const char *) pName, sizeof ("xglCreateColorBlendState")))
+        return disp_table->CreateColorBlendState;
+    else if (!strncmp("xglCreateDepthStencilState", (const char *) pName, sizeof ("xglCreateDepthStencilState")))
+        return disp_table->CreateDepthStencilState;
+    else if (!strncmp("xglCreateCommandBuffer", (const char *) pName, sizeof ("xglCreateCommandBuffer")))
+        return disp_table->CreateCommandBuffer;
+    else if (!strncmp("xglBeginCommandBuffer", (const char *) pName, sizeof ("xglBeginCommandBuffer")))
+        return disp_table->BeginCommandBuffer;
+    else if (!strncmp("xglEndCommandBuffer", (const char *) pName, sizeof ("xglEndCommandBuffer")))
+        return disp_table->EndCommandBuffer;
+    else if (!strncmp("xglResetCommandBuffer", (const char *) pName, sizeof ("xglResetCommandBuffer")))
+        return disp_table->ResetCommandBuffer;
+    else if (!strncmp("xglCmdBindPipeline", (const char *) pName, sizeof ("xglCmdBindPipeline")))
+        return disp_table->CmdBindPipeline;
+    else if (!strncmp("xglCmdBindPipelineDelta", (const char *) pName, sizeof ("xglCmdBindPipelineDelta")))
+        return disp_table->CmdBindPipelineDelta;
+    else if (!strncmp("xglCmdBindStateObject", (const char *) pName, sizeof ("xglCmdBindStateObject")))
+        return disp_table->CmdBindStateObject;
+    else if (!strncmp("xglCmdBindDescriptorSet", (const char *) pName, sizeof ("xglCmdBindDescriptorSet")))
+        return disp_table->CmdBindDescriptorSet;
+    else if (!strncmp("xglCmdBindDynamicMemoryView", (const char *) pName, sizeof ("xglCmdBindDynamicMemoryView")))
+        return disp_table->CmdBindDynamicMemoryView;
+    else if (!strncmp("xglCmdBindIndexData", (const char *) pName, sizeof ("xglCmdBindIndexData")))
+        return disp_table->CmdBindIndexData;
+    else if (!strncmp("xglCmdBindAttachments", (const char *) pName, sizeof ("xglCmdBindAttachments")))
+        return disp_table->CmdBindAttachments;
+    else if (!strncmp("xglCmdPrepareMemoryRegions", (const char *) pName, sizeof ("xglCmdPrepareMemoryRegions")))
+        return disp_table->CmdPrepareMemoryRegions;
+    else if (!strncmp("xglCmdPrepareImages", (const char *) pName, sizeof ("xglCmdPrepareImages")))
+        return disp_table->CmdPrepareImages;
+    else if (!strncmp("xglCmdDraw", (const char *) pName, sizeof ("xglCmdDraw")))
+        return disp_table->CmdDraw;
+    else if (!strncmp("xglCmdDrawIndexed", (const char *) pName, sizeof ("xglCmdDrawIndexed")))
+        return disp_table->CmdDrawIndexed;
+    else if (!strncmp("xglCmdDrawIndirect", (const char *) pName, sizeof ("xglCmdDrawIndirect")))
+        return disp_table->CmdDrawIndirect;
+    else if (!strncmp("xglCmdDrawIndexedIndirect", (const char *) pName, sizeof ("xglCmdDrawIndexedIndirect")))
+        return disp_table->CmdDrawIndexedIndirect;
+    else if (!strncmp("xglCmdDispatch", (const char *) pName, sizeof ("xglCmdDispatch")))
+        return disp_table->CmdDispatch;
+    else if (!strncmp("xglCmdDispatchIndirect", (const char *) pName, sizeof ("xglCmdDispatchIndirect")))
+        return disp_table->CmdDispatchIndirect;
+    else if (!strncmp("xglCmdCopyMemory", (const char *) pName, sizeof ("xglCmdCopyMemory")))
+        return disp_table->CmdCopyMemory;
+    else if (!strncmp("xglCmdCopyImage", (const char *) pName, sizeof ("xglCmdCopyImage")))
+        return disp_table->CmdCopyImage;
+    else if (!strncmp("xglCmdCopyMemoryToImage", (const char *) pName, sizeof ("xglCmdCopyMemoryToImage")))
+        return disp_table->CmdCopyMemoryToImage;
+    else if (!strncmp("xglCmdCopyImageToMemory", (const char *) pName, sizeof ("xglCmdCopyImageToMemory")))
+        return disp_table->CmdCopyImageToMemory;
+    else if (!strncmp("xglCmdCloneImageData", (const char *) pName, sizeof ("xglCmdCloneImageData")))
+        return disp_table->CmdCloneImageData;
+    else if (!strncmp("xglCmdUpdateMemory", (const char *) pName, sizeof ("xglCmdUpdateMemory")))
+        return disp_table->CmdUpdateMemory;
+    else if (!strncmp("xglCmdFillMemory", (const char *) pName, sizeof ("xglCmdFillMemory")))
+        return disp_table->CmdFillMemory;
+    else if (!strncmp("xglCmdClearColorImage", (const char *) pName, sizeof ("xglCmdClearColorImage")))
+        return disp_table->CmdClearColorImage;
+    else if (!strncmp("xglCmdClearColorImageRaw", (const char *) pName, sizeof ("xglCmdClearColorImageRaw")))
+        return disp_table->CmdClearColorImageRaw;
+    else if (!strncmp("xglCmdClearDepthStencil", (const char *) pName, sizeof ("xglCmdClearDepthStencil")))
+        return disp_table->CmdClearDepthStencil;
+    else if (!strncmp("xglCmdResolveImage", (const char *) pName, sizeof ("xglCmdResolveImage")))
+        return disp_table->CmdResolveImage;
+    else if (!strncmp("xglCmdSetEvent", (const char *) pName, sizeof ("xglCmdSetEvent")))
+        return disp_table->CmdSetEvent;
+    else if (!strncmp("xglCmdResetEvent", (const char *) pName, sizeof ("xglCmdResetEvent")))
+        return disp_table->CmdResetEvent;
+    else if (!strncmp("xglCmdMemoryAtomic", (const char *) pName, sizeof ("xglCmdMemoryAtomic")))
+        return disp_table->CmdMemoryAtomic;
+    else if (!strncmp("xglCmdBeginQuery", (const char *) pName, sizeof ("xglCmdBeginQuery")))
+        return disp_table->CmdBeginQuery;
+    else if (!strncmp("xglCmdEndQuery", (const char *) pName, sizeof ("xglCmdEndQuery")))
+        return disp_table->CmdEndQuery;
+    else if (!strncmp("xglCmdResetQueryPool", (const char *) pName, sizeof ("xglCmdResetQueryPool")))
+        return disp_table->CmdResetQueryPool;
+    else if (!strncmp("xglCmdWriteTimestamp", (const char *) pName, sizeof ("xglCmdWriteTimestamp")))
+        return disp_table->CmdWriteTimestamp;
+    else if (!strncmp("xglCmdInitAtomicCounters", (const char *) pName, sizeof ("xglCmdInitAtomicCounters")))
+        return disp_table->CmdInitAtomicCounters;
+    else if (!strncmp("xglCmdLoadAtomicCounters", (const char *) pName, sizeof ("xglCmdLoadAtomicCounters")))
+        return disp_table->CmdLoadAtomicCounters;
+    else if (!strncmp("xglCmdSaveAtomicCounters", (const char *) pName, sizeof ("xglCmdSaveAtomicCounters")))
+        return disp_table->CmdSaveAtomicCounters;
+    else if (!strncmp("xglDbgSetValidationLevel", (const char *) pName, sizeof ("xglDbgSetValidationLevel")))
+        return disp_table->DbgSetValidationLevel;
+    else if (!strncmp("xglDbgRegisterMsgCallback", (const char *) pName, sizeof ("xglDbgRegisterMsgCallback")))
+        return disp_table->DbgRegisterMsgCallback;
+    else if (!strncmp("xglDbgUnregisterMsgCallback", (const char *) pName, sizeof ("xglDbgUnregisterMsgCallback")))
+        return disp_table->DbgUnregisterMsgCallback;
+    else if (!strncmp("xglDbgSetMessageFilter", (const char *) pName, sizeof ("xglDbgSetMessageFilter")))
+        return disp_table->DbgSetMessageFilter;
+    else if (!strncmp("xglDbgSetObjectTag", (const char *) pName, sizeof ("xglDbgSetObjectTag")))
+        return disp_table->DbgSetObjectTag;
+    else if (!strncmp("xglDbgSetGlobalOption", (const char *) pName, sizeof ("xglDbgSetGlobalOption")))
+        return disp_table->DbgSetGlobalOption;
+    else if (!strncmp("xglDbgSetDeviceOption", (const char *) pName, sizeof ("xglDbgSetDeviceOption")))
+        return disp_table->DbgSetDeviceOption;
+    else if (!strncmp("xglCmdDbgMarkerBegin", (const char *) pName, sizeof ("xglCmdDbgMarkerBegin")))
+        return disp_table->CmdDbgMarkerBegin;
+    else if (!strncmp("xglCmdDbgMarkerEnd", (const char *) pName, sizeof ("xglCmdDbgMarkerEnd")))
+        return disp_table->CmdDbgMarkerEnd;
+    else if (!strncmp("xglWsiX11AssociateConnection", (const char *) pName, sizeof("xglWsiX11AssociateConnection")))
+        return disp_table->WsiX11AssociateConnection;
+    else if (!strncmp("xglWsiX11GetMSC", (const char *) pName, sizeof("xglWsiX11GetMSC")))
+        return disp_table->WsiX11GetMSC;
+    else if (!strncmp("xglWsiX11CreatePresentableImage", (const char *) pName, sizeof("xglWsiX11CreatePresentableImage")))
+        return disp_table->WsiX11CreatePresentableImage;
+    else if (!strncmp("xglWsiX11QueuePresent", (const char *) pName, sizeof("xglWsiX11QueuePresent")))
+        return disp_table->WsiX11QueuePresent;
+    else  {
+        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        if (gpuw->pGPA == NULL)
+            return NULL;
+        return gpuw->pGPA(gpuw->nextObject, pName);
+    }
+}
+
 LOADER_EXPORT XGL_RESULT XGLAPI xglInitAndEnumerateGpus(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb, XGL_UINT maxGpus, XGL_UINT* pGpuCount, XGL_PHYSICAL_GPU* pGpus)
 {
     static pthread_once_t once = PTHREAD_ONCE_INIT;
@@ -366,6 +971,8 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglInitAndEnumerateGpus(const XGL_APPLICATION_IN
     icd = loader.icds;
     while (icd) {
         XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];
+        XGL_BASE_LAYER_OBJECT * wrappedGpus;
+        GetProcAddrType getProcAddr = icd->GetProcAddr;
         XGL_UINT n, max = maxGpus - count;
 
         if (max > XGL_MAX_PHYSICAL_GPUS) {
@@ -374,7 +981,18 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglInitAndEnumerateGpus(const XGL_APPLICATION_IN
 
         res = icd->InitAndEnumerateGpus(pAppInfo, pAllocCb, max, &n, gpus);
         if (res == XGL_SUCCESS && n) {
-            memcpy(pGpus + count, gpus, sizeof(*pGpus) * n);
+            wrappedGpus = (XGL_BASE_LAYER_OBJECT*) malloc(n * sizeof(XGL_BASE_LAYER_OBJECT));
+            loader.loader_dispatch = (XGL_LAYER_DISPATCH_TABLE *) malloc(n * sizeof(XGL_LAYER_DISPATCH_TABLE));
+            for (int i = 0; i < n; i++) {
+                (wrappedGpus + i)->baseObject = gpus[i];
+                (wrappedGpus + i)->pGPA = getProcAddr; //loader.loader_dispatch + i; //getProcAddr;
+                (wrappedGpus + i)->nextObject = gpus[i];
+                memcpy(pGpus + count, &wrappedGpus, sizeof(*pGpus));
+                init_dispatch_table(loader.loader_dispatch + i, getProcAddr, wrappedGpus + i);
+                const XGL_LAYER_DISPATCH_TABLE * *disp = (const XGL_LAYER_DISPATCH_TABLE *  *) gpus[i];
+                *disp = loader.loader_dispatch + i;
+            }
+
             count += n;
 
             if (count >= maxGpus) {
@@ -385,6 +1003,10 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglInitAndEnumerateGpus(const XGL_APPLICATION_IN
         icd = icd->next;
     }
 
+    /* get layer libraries */
+    if (!loader.layer_scaned)
+        layer_lib_scan(NULL, true, false);
+
     *pGpuCount = count;
 
     return (count > 0) ? XGL_SUCCESS : res;
diff --git a/loader/loader.h b/loader/loader.h
index b76f6344..d8191421 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -31,7 +31,7 @@
 #include <xgl.h>
 #include <xglDbg.h>
 #include <xglWsiX11Ext.h>
-
+#include <xglLayer.h>
 #if defined(__GNUC__) && __GNUC__ >= 4
 #  define LOADER_EXPORT __attribute__((visibility("default")))
 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
@@ -40,4 +40,6 @@
 #  define LOADER_EXPORT
 #endif
 
+extern XGL_UINT ActivateLayers(XGL_PHYSICAL_GPU *gpu);
+#define MAX_LAYER_LIBRARIES 16
 #endif /* LOADER_H */
diff --git a/xgl-generate.py b/xgl-generate.py
index 900f50cd..6e790d8a 100755
--- a/xgl-generate.py
+++ b/xgl-generate.py
@@ -108,36 +108,149 @@ class Subcommand(object):
     %s;
 };""" % ";\n    ".join(entries)
 
-    def _generate_icd_dispatch_entrypoints(self, qual=""):
+    def _generate_dispatch_entrypoints(self, qual="", unwrap=False, layer=False):
         if qual:
             qual += " "
 
         funcs = []
         for proto in self.protos:
-            if not xgl.is_dispatchable(proto):
-                continue
+            if not layer:
+                if not xgl.is_dispatchable(proto):
+                    continue
+                decl = proto.c_func(prefix="xgl", attr="XGLAPI")
+                stmt = "(*disp)->%s" % proto.c_call()
+                if proto.ret != "XGL_VOID":
+                    stmt = "return " + stmt
+                if proto.name == "CreateDevice" and qual == "LOADER_EXPORT ":
+                    stmt_cd = "XGL_RESULT res = " + "(*disp)->%s" % proto.c_call()
+                    funcs.append("%s%s\n"
+                             "{\n"
+                             "    ActivateLayers(&%s);\n"
+                             "    XGL_BASE_LAYER_OBJECT* wrapped_obj = (XGL_BASE_LAYER_OBJECT*)%s;\n"
+                             "    const XGL_LAYER_DISPATCH_TABLE * const *disp =\n"
+                             "            (const XGL_LAYER_DISPATCH_TABLE * const *) wrapped_obj->baseObject;\n"
+                             "    %s = wrapped_obj->nextObject;\n"
+                             "    %s;\n"
+                             "    const XGL_LAYER_DISPATCH_TABLE * *disp_dev = (const XGL_LAYER_DISPATCH_TABLE *  *) *%s;\n"
+                             "    *disp_dev = (const XGL_LAYER_DISPATCH_TABLE *) *disp;\n"
+                             "    return res;\n"
+                             "}" % (qual, decl, proto.params[0].name, proto.params[0].name, proto.params[0].name, stmt_cd, proto.params[2].name))
+                elif proto.params[0].ty != "XGL_PHYSICAL_GPU":
+                    funcs.append("%s%s\n"
+                             "{\n"
+                             "    const XGL_LAYER_DISPATCH_TABLE * const *disp =\n"
+                             "        (const XGL_LAYER_DISPATCH_TABLE * const *) %s;\n"
+                             "    %s;\n"
+                             "}" % (qual, decl, proto.params[0].name, stmt))
+                else:
+                    funcs.append("%s%s\n"
+                             "{\n"
+                             "    XGL_BASE_LAYER_OBJECT* wrapped_obj = (XGL_BASE_LAYER_OBJECT*)%s;\n"
+                             "    const XGL_LAYER_DISPATCH_TABLE * const *disp =\n"
+                             "        (const XGL_LAYER_DISPATCH_TABLE * const *) wrapped_obj->baseObject;\n"
+                             "    %s = wrapped_obj->nextObject;\n"
+                             "    %s;\n"
+                                 "}" % (qual, decl, proto.params[0].name, proto.params[0].name, stmt))
+            elif proto.name != "GetProcAddr":
+                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))
 
-            decl = proto.c_func(prefix="xgl", attr="XGLAPI")
-            stmt = "(*disp)->%s" % proto.c_call()
-            if proto.ret != "XGL_VOID":
-                stmt = "return " + stmt
+        return "\n\n".join(funcs)
 
-            funcs.append("%s%s\n"
+    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"
-                         "    const struct icd_dispatch_table * const *disp =\n"
-                         "        (const struct icd_dispatch_table * const *) %s;\n"
-                         "    %s;\n"
-                         "}" % (qual, decl, proto.params[0].name, stmt))
+                         "    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
+            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');
 
-        return "\n\n".join(funcs)
+        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 LoaderSubcommand(Subcommand):
     def generate_header(self):
         return "#include \"loader.h\""
 
     def generate_body(self):
-        body = [self._generate_icd_dispatch_table(),
-                self._generate_icd_dispatch_entrypoints("LOADER_EXPORT")]
+        body = [self._generate_dispatch_entrypoints("LOADER_EXPORT")]
+
+        return "\n\n".join(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", True, True),
+                self._generate_layer_gpa_function()]
 
         return "\n\n".join(body)
 
@@ -150,7 +263,7 @@ class IcdDispatchEntrypointsSubcommand(Subcommand):
         return "#include \"icd.h\""
 
     def generate_body(self):
-        return self._generate_icd_dispatch_entrypoints("ICD_EXPORT")
+        return self._generate_dispatch_entrypoints("ICD_EXPORT")
 
 class IcdDispatchDummyImplSubcommand(Subcommand):
     def run(self):
@@ -224,6 +337,9 @@ const struct icd_dispatch_table %s_debug_dispatch_table = {
 def main():
     subcommands = {
             "loader": LoaderSubcommand,
+            "layer-funcs" : LayerFuncsSubcommand,
+            "layer-dispatch" : LayerDispatchSubcommand,
+            "generic-layer" : GenericLayerSubcommand,
             "icd-dispatch-table": IcdDispatchTableSubcommand,
             "icd-dispatch-entrypoints": IcdDispatchEntrypointsSubcommand,
             "icd-dispatch-dummy-impl": IcdDispatchDummyImplSubcommand,
diff --git a/xgl.py b/xgl.py
index 62ae0fb8..6f2b7387 100644
--- a/xgl.py
+++ b/xgl.py
@@ -87,6 +87,10 @@ class Proto(object):
 
 # XGL core API
 core = (
+    Proto("void *", "GetProcAddr",
+        (Param("XGL_PHYSICAL_GPU", "gpu"),
+         Param("const XGL_CHAR*", "pName"))),
+
     Proto("XGL_RESULT", "InitAndEnumerateGpus",
         (Param("const XGL_APPLICATION_INFO*", "pAppInfo"),
          Param("const XGL_ALLOC_CALLBACKS*", "pAllocCb"),
@@ -726,6 +730,7 @@ ext_wsi_x11_headers = ("xglWsiX11Ext.h",)
 # XXX figure out the real order
 # XXX this is not extensible
 icd_dispatch_table = (
+    "GetProcAddr",
     "InitAndEnumerateGpus",
     "GetGpuInfo",
     "CreateDevice",
@@ -847,14 +852,18 @@ icd_dispatch_table = (
     "WsiX11QueuePresent",
 )
 
+def is_name_dispatchable(name):
+    return name not in (
+        "GetProcAddr",
+        "InitAndEnumerateGpus",
+        "DbgRegisterMsgCallback",
+        "DbgUnregisterMsgCallback",
+        "DbgSetGlobalOption")
+
 def is_dispatchable(proto):
     """Return true if the prototype is dispatchable.
 
     That is, return true when the prototype takes a XGL_PHYSICAL_GPU or
     XGL_BASE_OBJECT.
     """
-    return proto.name not in (
-        "InitAndEnumerateGpus",
-        "DbgRegisterMsgCallback",
-        "DbgUnregisterMsgCallback",
-        "DbgSetGlobalOption")
+    return is_name_dispatchable(proto.name)