diff --git a/layers/basic.cpp b/layers/basic.cpp
index 300a6bb..f060bb8 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -132,7 +132,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
 {
     if (device == NULL)
         return NULL;
@@ -140,15 +140,15 @@
     /* loader uses this to force layer initialization; device object is wrapped */
     if (!strcmp("vkGetDeviceProcAddr", pName)) {
         initDeviceTable((const VkBaseLayerObject *) device);
-        return (void *) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
     }
 
     if (!strcmp("vkCreateDevice", pName))
-        return (void *) basic_CreateDevice;
+        return (PFN_vkVoidFunction) basic_CreateDevice;
     if (!strcmp("vkDestroyDevice", pName))
-        return (void *) basic_DestroyDevice;
+        return (PFN_vkVoidFunction) basic_DestroyDevice;
     if (!strcmp("vkLayerExtension1", pName))
-        return (void *) vkLayerExtension1;
+        return (PFN_vkVoidFunction) vkLayerExtension1;
     else
     {
         if (device_dispatch_table(device)->GetDeviceProcAddr == NULL)
@@ -157,7 +157,7 @@
     }
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* pName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* pName)
 {
     if (instance == NULL)
         return NULL;
@@ -165,19 +165,19 @@
     /* loader uses this to force layer initialization; instance object is wrapped */
     if (!strcmp("vkGetInstanceProcAddr", pName)) {
         initInstanceTable((const VkBaseLayerObject *) instance);
-        return (void *) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
     }
 
     if (!strcmp("vkGetPhysicalDeviceLayerProperties", pName))
-        return (void *) vkGetPhysicalDeviceLayerProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceLayerProperties;
     if (!strcmp("vkGetPhysicalDeviceExtensionProperties", pName))
-        return (void *) vkGetPhysicalDeviceExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceExtensionProperties;
     if (!strcmp("vkGetPhysicalDeviceFormatProperties", pName))
-        return (void *) basic_GetPhysicalDeviceFormatProperties;
+        return (PFN_vkVoidFunction) basic_GetPhysicalDeviceFormatProperties;
     if (!strcmp("vkDestroyInstance", pName))
-        return (void *) basic_DestroyInstance;
+        return (PFN_vkVoidFunction) basic_DestroyInstance;
     if (!strcmp("vkEnumeratePhysicalDevices", pName))
-        return (void*) basic_EnumeratePhysicalDevices;
+        return (PFN_vkVoidFunction) basic_EnumeratePhysicalDevices;
 
     if (instance_dispatch_table(instance)->GetInstanceProcAddr == NULL)
         return NULL;
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 5d31cd8..7f7d41e 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2989,7 +2989,7 @@
 //    debug_marker_dispatch_table(device)->DbgSetObjectName(device, objType, object, nameSize, pName);
 //}
 
-VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
 {
     if (dev == NULL)
         return NULL;
@@ -2997,196 +2997,196 @@
     /* loader uses this to force layer initialization; device object is wrapped */
     if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
         initDeviceTable(draw_state_device_table_map, (const VkBaseLayerObject *) dev);
-        return (void *) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
     }
     if (!strcmp(funcName, "vkCreateDevice"))
-        return (void*) vkCreateDevice;
+        return (PFN_vkVoidFunction) vkCreateDevice;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (void*) vkDestroyDevice;
+        return (PFN_vkVoidFunction) vkDestroyDevice;
     if (!strcmp(funcName, "vkQueueSubmit"))
-        return (void*) vkQueueSubmit;
+        return (PFN_vkVoidFunction) vkQueueSubmit;
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (void*) vkDestroyInstance;
+        return (PFN_vkVoidFunction) vkDestroyInstance;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (void*) vkDestroyDevice;
+        return (PFN_vkVoidFunction) vkDestroyDevice;
     if (!strcmp(funcName, "vkDestroyFence"))
-        return (void*) vkDestroyFence;
+        return (PFN_vkVoidFunction) vkDestroyFence;
     if (!strcmp(funcName, "vkDestroySemaphore"))
-        return (void*) vkDestroySemaphore;
+        return (PFN_vkVoidFunction) vkDestroySemaphore;
     if (!strcmp(funcName, "vkDestroyEvent"))
-        return (void*) vkDestroyEvent;
+        return (PFN_vkVoidFunction) vkDestroyEvent;
     if (!strcmp(funcName, "vkDestroyQueryPool"))
-        return (void*) vkDestroyQueryPool;
+        return (PFN_vkVoidFunction) vkDestroyQueryPool;
     if (!strcmp(funcName, "vkDestroyBuffer"))
-        return (void*) vkDestroyBuffer;
+        return (PFN_vkVoidFunction) vkDestroyBuffer;
     if (!strcmp(funcName, "vkDestroyBufferView"))
-        return (void*) vkDestroyBufferView;
+        return (PFN_vkVoidFunction) vkDestroyBufferView;
     if (!strcmp(funcName, "vkDestroyImage"))
-        return (void*) vkDestroyImage;
+        return (PFN_vkVoidFunction) vkDestroyImage;
     if (!strcmp(funcName, "vkDestroyImageView"))
-        return (void*) vkDestroyImageView;
+        return (PFN_vkVoidFunction) vkDestroyImageView;
     if (!strcmp(funcName, "vkDestroyAttachmentView"))
-        return (void*) vkDestroyAttachmentView;
+        return (PFN_vkVoidFunction) vkDestroyAttachmentView;
     if (!strcmp(funcName, "vkDestroyShaderModule"))
-        return (void*) vkDestroyShaderModule;
+        return (PFN_vkVoidFunction) vkDestroyShaderModule;
     if (!strcmp(funcName, "vkDestroyShader"))
-        return (void*) vkDestroyShader;
+        return (PFN_vkVoidFunction) vkDestroyShader;
     if (!strcmp(funcName, "vkDestroyPipeline"))
-        return (void*) vkDestroyPipeline;
+        return (PFN_vkVoidFunction) vkDestroyPipeline;
     if (!strcmp(funcName, "vkDestroyPipelineLayout"))
-        return (void*) vkDestroyPipelineLayout;
+        return (PFN_vkVoidFunction) vkDestroyPipelineLayout;
     if (!strcmp(funcName, "vkDestroySampler"))
-        return (void*) vkDestroySampler;
+        return (PFN_vkVoidFunction) vkDestroySampler;
     if (!strcmp(funcName, "vkDestroyDescriptorSetLayout"))
-        return (void*) vkDestroyDescriptorSetLayout;
+        return (PFN_vkVoidFunction) vkDestroyDescriptorSetLayout;
     if (!strcmp(funcName, "vkDestroyDescriptorPool"))
-        return (void*) vkDestroyDescriptorPool;
+        return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
     if (!strcmp(funcName, "vkDestroyDynamicViewportState"))
-        return (void*) vkDestroyDynamicViewportState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicViewportState;
     if (!strcmp(funcName, "vkDestroyDynamicRasterState"))
-        return (void*) vkDestroyDynamicRasterState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicRasterState;
     if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
-        return (void*) vkDestroyDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
     if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
-        return (void*) vkDestroyDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicDepthStencilState;
     if (!strcmp(funcName, "vkDestroyCommandBuffer"))
-        return (void*) vkDestroyCommandBuffer;
+        return (PFN_vkVoidFunction) vkDestroyCommandBuffer;
     if (!strcmp(funcName, "vkDestroyFramebuffer"))
-        return (void*) vkDestroyFramebuffer;
+        return (PFN_vkVoidFunction) vkDestroyFramebuffer;
     if (!strcmp(funcName, "vkDestroyRenderPass"))
-        return (void*) vkDestroyRenderPass;
+        return (PFN_vkVoidFunction) vkDestroyRenderPass;
     if (!strcmp(funcName, "vkCreateBufferView"))
-        return (void*) vkCreateBufferView;
+        return (PFN_vkVoidFunction) vkCreateBufferView;
     if (!strcmp(funcName, "vkCreateImageView"))
-        return (void*) vkCreateImageView;
+        return (PFN_vkVoidFunction) vkCreateImageView;
     if (!strcmp(funcName, "vkCreateAttachmentView"))
-        return (void*) vkCreateAttachmentView;
+        return (PFN_vkVoidFunction) vkCreateAttachmentView;
     if (!strcmp(funcName, "CreatePipelineCache"))
-        return (void*) vkCreatePipelineCache;
+        return (PFN_vkVoidFunction) vkCreatePipelineCache;
     if (!strcmp(funcName, "DestroyPipelineCache"))
-        return (void*) vkDestroyPipelineCache;
+        return (PFN_vkVoidFunction) vkDestroyPipelineCache;
     if (!strcmp(funcName, "GetPipelineCacheSize"))
-        return (void*) vkGetPipelineCacheSize;
+        return (PFN_vkVoidFunction) vkGetPipelineCacheSize;
     if (!strcmp(funcName, "GetPipelineCacheData"))
-        return (void*) vkGetPipelineCacheData;
+        return (PFN_vkVoidFunction) vkGetPipelineCacheData;
     if (!strcmp(funcName, "MergePipelineCaches"))
-        return (void*) vkMergePipelineCaches;
+        return (PFN_vkVoidFunction) vkMergePipelineCaches;
     if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
-        return (void*) vkCreateGraphicsPipelines;
+        return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
     if (!strcmp(funcName, "vkCreateSampler"))
-        return (void*) vkCreateSampler;
+        return (PFN_vkVoidFunction) vkCreateSampler;
     if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
-        return (void*) vkCreateDescriptorSetLayout;
+        return (PFN_vkVoidFunction) vkCreateDescriptorSetLayout;
     if (!strcmp(funcName, "vkCreatePipelineLayout"))
-        return (void*) vkCreatePipelineLayout;
+        return (PFN_vkVoidFunction) vkCreatePipelineLayout;
     if (!strcmp(funcName, "vkCreateDescriptorPool"))
-        return (void*) vkCreateDescriptorPool;
+        return (PFN_vkVoidFunction) vkCreateDescriptorPool;
     if (!strcmp(funcName, "vkResetDescriptorPool"))
-        return (void*) vkResetDescriptorPool;
+        return (PFN_vkVoidFunction) vkResetDescriptorPool;
     if (!strcmp(funcName, "vkAllocDescriptorSets"))
-        return (void*) vkAllocDescriptorSets;
+        return (PFN_vkVoidFunction) vkAllocDescriptorSets;
     if (!strcmp(funcName, "vkUpdateDescriptorSets"))
-        return (void*) vkUpdateDescriptorSets;
+        return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
     if (!strcmp(funcName, "vkCreateDynamicViewportState"))
-        return (void*) vkCreateDynamicViewportState;
+        return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
     if (!strcmp(funcName, "vkCreateDynamicRasterState"))
-        return (void*) vkCreateDynamicRasterState;
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
-        return (void*) vkCreateDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
     if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
-        return (void*) vkCreateDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkCreateDynamicDepthStencilState;
     if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (void*) vkCreateCommandBuffer;
+        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
-        return (void*) vkBeginCommandBuffer;
+        return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
-        return (void*) vkEndCommandBuffer;
+        return (PFN_vkVoidFunction) vkEndCommandBuffer;
     if (!strcmp(funcName, "vkResetCommandBuffer"))
-        return (void*) vkResetCommandBuffer;
+        return (PFN_vkVoidFunction) vkResetCommandBuffer;
     if (!strcmp(funcName, "vkCmdBindPipeline"))
-        return (void*) vkCmdBindPipeline;
+        return (PFN_vkVoidFunction) vkCmdBindPipeline;
     if (!strcmp(funcName, "vkCmdBindDynamicViewportState"))
-        return (void*) vkCmdBindDynamicViewportState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState;
     if (!strcmp(funcName, "vkCmdBindDynamicRasterState"))
-        return (void*) vkCmdBindDynamicRasterState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState;
     if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
-        return (void*) vkCmdBindDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
     if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
-        return (void*) vkCmdBindDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicDepthStencilState;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
-        return (void*) vkCmdBindDescriptorSets;
+        return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
     if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
-        return (void*) vkCmdBindVertexBuffers;
+        return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
     if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
-        return (void*) vkCmdBindIndexBuffer;
+        return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
     if (!strcmp(funcName, "vkCmdDraw"))
-        return (void*) vkCmdDraw;
+        return (PFN_vkVoidFunction) vkCmdDraw;
     if (!strcmp(funcName, "vkCmdDrawIndexed"))
-        return (void*) vkCmdDrawIndexed;
+        return (PFN_vkVoidFunction) vkCmdDrawIndexed;
     if (!strcmp(funcName, "vkCmdDrawIndirect"))
-        return (void*) vkCmdDrawIndirect;
+        return (PFN_vkVoidFunction) vkCmdDrawIndirect;
     if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
-        return (void*) vkCmdDrawIndexedIndirect;
+        return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
     if (!strcmp(funcName, "vkCmdDispatch"))
-        return (void*) vkCmdDispatch;
+        return (PFN_vkVoidFunction) vkCmdDispatch;
     if (!strcmp(funcName, "vkCmdDispatchIndirect"))
-        return (void*) vkCmdDispatchIndirect;
+        return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
     if (!strcmp(funcName, "vkCmdCopyBuffer"))
-        return (void*) vkCmdCopyBuffer;
+        return (PFN_vkVoidFunction) vkCmdCopyBuffer;
     if (!strcmp(funcName, "vkCmdCopyImage"))
-        return (void*) vkCmdCopyImage;
+        return (PFN_vkVoidFunction) vkCmdCopyImage;
     if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
-        return (void*) vkCmdCopyBufferToImage;
+        return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
     if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
-        return (void*) vkCmdCopyImageToBuffer;
+        return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
     if (!strcmp(funcName, "vkCmdUpdateBuffer"))
-        return (void*) vkCmdUpdateBuffer;
+        return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
     if (!strcmp(funcName, "vkCmdFillBuffer"))
-        return (void*) vkCmdFillBuffer;
+        return (PFN_vkVoidFunction) vkCmdFillBuffer;
     if (!strcmp(funcName, "vkCmdClearColorImage"))
-        return (void*) vkCmdClearColorImage;
+        return (PFN_vkVoidFunction) vkCmdClearColorImage;
     if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
-        return (void*) vkCmdClearDepthStencilImage;
+        return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage;
     if (!strcmp(funcName, "vkCmdClearColorAttachment"))
-        return (void*) vkCmdClearColorAttachment;
+        return (PFN_vkVoidFunction) vkCmdClearColorAttachment;
     if (!strcmp(funcName, "vkCmdClearDepthStencilAttachment"))
-        return (void*) vkCmdClearDepthStencilAttachment;
+        return (PFN_vkVoidFunction) vkCmdClearDepthStencilAttachment;
     if (!strcmp(funcName, "vkCmdResolveImage"))
-        return (void*) vkCmdResolveImage;
+        return (PFN_vkVoidFunction) vkCmdResolveImage;
     if (!strcmp(funcName, "vkCmdSetEvent"))
-        return (void*) vkCmdSetEvent;
+        return (PFN_vkVoidFunction) vkCmdSetEvent;
     if (!strcmp(funcName, "vkCmdResetEvent"))
-        return (void*) vkCmdResetEvent;
+        return (PFN_vkVoidFunction) vkCmdResetEvent;
     if (!strcmp(funcName, "vkCmdWaitEvents"))
-        return (void*) vkCmdWaitEvents;
+        return (PFN_vkVoidFunction) vkCmdWaitEvents;
     if (!strcmp(funcName, "vkCmdPipelineBarrier"))
-        return (void*) vkCmdPipelineBarrier;
+        return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
     if (!strcmp(funcName, "vkCmdBeginQuery"))
-        return (void*) vkCmdBeginQuery;
+        return (PFN_vkVoidFunction) vkCmdBeginQuery;
     if (!strcmp(funcName, "vkCmdEndQuery"))
-        return (void*) vkCmdEndQuery;
+        return (PFN_vkVoidFunction) vkCmdEndQuery;
     if (!strcmp(funcName, "vkCmdResetQueryPool"))
-        return (void*) vkCmdResetQueryPool;
+        return (PFN_vkVoidFunction) vkCmdResetQueryPool;
     if (!strcmp(funcName, "vkCmdWriteTimestamp"))
-        return (void*) vkCmdWriteTimestamp;
+        return (PFN_vkVoidFunction) vkCmdWriteTimestamp;
     if (!strcmp(funcName, "vkCreateFramebuffer"))
-        return (void*) vkCreateFramebuffer;
+        return (PFN_vkVoidFunction) vkCreateFramebuffer;
     if (!strcmp(funcName, "vkCreateRenderPass"))
-        return (void*) vkCreateRenderPass;
+        return (PFN_vkVoidFunction) vkCreateRenderPass;
     if (!strcmp(funcName, "vkCmdBeginRenderPass"))
-        return (void*) vkCmdBeginRenderPass;
+        return (PFN_vkVoidFunction) vkCmdBeginRenderPass;
     if (!strcmp(funcName, "vkCmdNextSubpass"))
-        return (void*) vkCmdNextSubpass;
+        return (PFN_vkVoidFunction) vkCmdNextSubpass;
     if (!strcmp(funcName, "vkCmdEndRenderPass"))
-        return (void*) vkCmdEndRenderPass;
+        return (PFN_vkVoidFunction) vkCmdEndRenderPass;
 
     VkLayerDispatchTable* pTable = get_dispatch_table(draw_state_device_table_map, dev);
     if (deviceExtMap.size() == 0 || deviceExtMap[pTable].debug_marker_enabled)
     {
         if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
-            return (void*) vkCmdDbgMarkerBegin;
+            return (PFN_vkVoidFunction) vkCmdDbgMarkerBegin;
         if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
-            return (void*) vkCmdDbgMarkerEnd;
+            return (PFN_vkVoidFunction) vkCmdDbgMarkerEnd;
 //        if (!strcmp(funcName, "vkDbgSetObjectTag"))
 //            return (void*) vkDbgSetObjectTag;
 //        if (!strcmp(funcName, "vkDbgSetObjectName"))
@@ -3199,29 +3199,29 @@
     }
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
 {
-    void *fptr;
+    PFN_vkVoidFunction fptr;
     if (instance == NULL)
         return NULL;
 
     /* loader uses this to force layer initialization; instance object is wrapped */
     if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
         initInstanceTable(draw_state_instance_table_map, (const VkBaseLayerObject *) instance);
-        return (void *) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
     }
     if (!strcmp(funcName, "vkCreateInstance"))
-        return (void *) vkCreateInstance;
+        return (PFN_vkVoidFunction) vkCreateInstance;
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (void *) vkDestroyInstance;
+        return (PFN_vkVoidFunction) vkDestroyInstance;
     if (!strcmp(funcName, "vkGetGlobalLayerProperties"))
-        return (void*) vkGetGlobalLayerProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalLayerProperties;
     if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
-        return (void*) vkGetGlobalExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalExtensionProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceLayerProperties"))
-        return (void*) vkGetPhysicalDeviceLayerProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceLayerProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
-        return (void*) vkGetPhysicalDeviceExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceExtensionProperties;
 
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
diff --git a/layers/image.cpp b/layers/image.cpp
index fadc611..4520fa1 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -335,7 +335,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
 {
     if (device == NULL) {
         return NULL;
@@ -344,17 +344,17 @@
     /* loader uses this to force layer initialization; device object is wrapped */
     if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
         initDeviceTable(image_device_table_map, (const VkBaseLayerObject *) device);
-        return (void*) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
     }
 
     if (!strcmp(funcName, "vkCreateDevice"))
-        return (void*) vkCreateDevice;
+        return (PFN_vkVoidFunction) vkCreateDevice;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (void*) vkDestroyDevice;
+        return (PFN_vkVoidFunction) vkDestroyDevice;
     if (!strcmp(funcName, "vkCreateImage"))
-        return (void*) vkCreateImage;
+        return (PFN_vkVoidFunction) vkCreateImage;
     if (!strcmp(funcName, "vkCreateRenderPass"))
-        return (void*) vkCreateRenderPass;
+        return (PFN_vkVoidFunction) vkCreateRenderPass;
 
     {
         if (get_dispatch_table(image_device_table_map, device)->GetDeviceProcAddr == NULL)
@@ -363,7 +363,7 @@
     }
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
 {
     if (instance == NULL) {
         return NULL;
@@ -372,24 +372,24 @@
     /* loader uses this to force layer initialization; instance object is wrapped */
     if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
         initInstanceTable(image_instance_table_map, (const VkBaseLayerObject *) instance);
-        return (void *) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
     }
 
     if (!strcmp(funcName, "vkCreateInstance"))
-        return (void*) vkCreateInstance;
+        return (PFN_vkVoidFunction) vkCreateInstance;
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (void *) vkDestroyInstance;
+        return (PFN_vkVoidFunction) vkDestroyInstance;
     if (!strcmp(funcName, "vkGetGlobalLayerProperties"))
-        return (void*) vkGetGlobalLayerProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalLayerProperties;
     if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
-        return (void*) vkGetGlobalExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalExtensionProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceLayerProperties"))
-        return (void*) vkGetPhysicalDeviceLayerProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceLayerProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
-        return (void*) vkGetPhysicalDeviceExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceExtensionProperties;
 
     layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    void* fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
+    PFN_vkVoidFunction fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
     if(fptr)
         return fptr;
 
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 80a86a2..687012f 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -2960,7 +2960,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
     VkDevice         dev,
     const char       *funcName)
 {
@@ -2971,188 +2971,188 @@
     /* loader uses this to force layer initialization; device object is wrapped */
     if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
         initDeviceTable(mem_tracker_device_table_map, (const VkBaseLayerObject *) dev);
-        return (void *) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
     }
     if (!strcmp(funcName, "vkCreateDevice"))
-        return (void*) vkCreateDevice;
+        return (PFN_vkVoidFunction) vkCreateDevice;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (void*) vkDestroyDevice;
+        return (PFN_vkVoidFunction) vkDestroyDevice;
     if (!strcmp(funcName, "vkQueueSubmit"))
-        return (void*) vkQueueSubmit;
+        return (PFN_vkVoidFunction) vkQueueSubmit;
     if (!strcmp(funcName, "vkAllocMemory"))
-        return (void*) vkAllocMemory;
+        return (PFN_vkVoidFunction) vkAllocMemory;
     if (!strcmp(funcName, "vkFreeMemory"))
-        return (void*) vkFreeMemory;
+        return (PFN_vkVoidFunction) vkFreeMemory;
     if (!strcmp(funcName, "vkMapMemory"))
-        return (void*) vkMapMemory;
+        return (PFN_vkVoidFunction) vkMapMemory;
     if (!strcmp(funcName, "vkUnmapMemory"))
-        return (void*) vkUnmapMemory;
+        return (PFN_vkVoidFunction) vkUnmapMemory;
     if (!strcmp(funcName, "vkDestroyFence"))
-        return (void*) vkDestroyFence;
+        return (PFN_vkVoidFunction) vkDestroyFence;
     if (!strcmp(funcName, "vkDestroyBuffer"))
-        return (void*) vkDestroyBuffer;
+        return (PFN_vkVoidFunction) vkDestroyBuffer;
     if (!strcmp(funcName, "vkDestroyImage"))
-        return (void*) vkDestroyImage;
+        return (PFN_vkVoidFunction) vkDestroyImage;
     if (!strcmp(funcName, "vkDestroyAttachmentView"))
-        return (void*) vkDestroyAttachmentView;
+        return (PFN_vkVoidFunction) vkDestroyAttachmentView;
     if (!strcmp(funcName, "vkDestroyImageView"))
-        return (void*) vkDestroyImageView;
+        return (PFN_vkVoidFunction) vkDestroyImageView;
     if (!strcmp(funcName, "vkDestroyPipeline"))
-        return (void*) vkDestroyPipeline;
+        return (PFN_vkVoidFunction) vkDestroyPipeline;
     if (!strcmp(funcName, "vkDestroySampler"))
-        return (void*) vkDestroySampler;
+        return (PFN_vkVoidFunction) vkDestroySampler;
     if (!strcmp(funcName, "vkDestroySemaphore"))
-        return (void*) vkDestroySemaphore;
+        return (PFN_vkVoidFunction) vkDestroySemaphore;
     if (!strcmp(funcName, "vkDestroyEvent"))
-        return (void*) vkDestroyEvent;
+        return (PFN_vkVoidFunction) vkDestroyEvent;
     if (!strcmp(funcName, "vkDestroyQueryPool"))
-        return (void*) vkDestroyQueryPool;
+        return (PFN_vkVoidFunction) vkDestroyQueryPool;
     if (!strcmp(funcName, "vkDestroyBufferView"))
-        return (void*) vkDestroyBufferView;
+        return (PFN_vkVoidFunction) vkDestroyBufferView;
     if (!strcmp(funcName, "vkDestroyShaderModule"))
-        return (void*) vkDestroyShaderModule;
+        return (PFN_vkVoidFunction) vkDestroyShaderModule;
     if (!strcmp(funcName, "vkDestroyShader"))
-        return (void*) vkDestroyShader;
+        return (PFN_vkVoidFunction) vkDestroyShader;
     if (!strcmp(funcName, "vkDestroyPipelineLayout"))
-        return (void*) vkDestroyPipelineLayout;
+        return (PFN_vkVoidFunction) vkDestroyPipelineLayout;
     if (!strcmp(funcName, "vkDestroyDescriptorSetLayout"))
-        return (void*) vkDestroyDescriptorSetLayout;
+        return (PFN_vkVoidFunction) vkDestroyDescriptorSetLayout;
     if (!strcmp(funcName, "vkDestroyDescriptorPool"))
-        return (void*) vkDestroyDescriptorPool;
+        return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
     if (!strcmp(funcName, "vkDestroyRenderPass"))
-        return (void*) vkDestroyRenderPass;
+        return (PFN_vkVoidFunction) vkDestroyRenderPass;
     if (!strcmp(funcName, "vkDestroyFramebuffer"))
-        return (void*) vkDestroyFramebuffer;
+        return (PFN_vkVoidFunction) vkDestroyFramebuffer;
     if (!strcmp(funcName, "vkDestroyDynamicViewportState"))
-        return (void*) vkDestroyDynamicViewportState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicViewportState;
     if (!strcmp(funcName, "vkDestroyDynamicRasterState"))
-        return (void*) vkDestroyDynamicRasterState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicRasterState;
     if (!strcmp(funcName, "vkDestroyDynamicColorBlendState"))
-        return (void*) vkDestroyDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicColorBlendState;
     if (!strcmp(funcName, "vkDestroyDynamicDepthStencilState"))
-        return (void*) vkDestroyDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkDestroyDynamicDepthStencilState;
     if (!strcmp(funcName, "vkBindBufferMemory"))
-        return (void*) vkBindBufferMemory;
+        return (PFN_vkVoidFunction) vkBindBufferMemory;
     if (!strcmp(funcName, "vkBindImageMemory"))
-        return (void*) vkBindImageMemory;
+        return (PFN_vkVoidFunction) vkBindImageMemory;
     if (!strcmp(funcName, "vkGetBufferMemoryRequirements"))
-        return (void*) vkGetBufferMemoryRequirements;
+        return (PFN_vkVoidFunction) vkGetBufferMemoryRequirements;
     if (!strcmp(funcName, "vkGetImageMemoryRequirements"))
-        return (void*) vkGetImageMemoryRequirements;
+        return (PFN_vkVoidFunction) vkGetImageMemoryRequirements;
     if (!strcmp(funcName, "vkQueueBindSparseBufferMemory"))
-        return (void*) vkQueueBindSparseBufferMemory;
+        return (PFN_vkVoidFunction) vkQueueBindSparseBufferMemory;
     if (!strcmp(funcName, "vkQueueBindSparseImageOpaqueMemory"))
-        return (void*) vkQueueBindSparseImageOpaqueMemory;
+        return (PFN_vkVoidFunction) vkQueueBindSparseImageOpaqueMemory;
     if (!strcmp(funcName, "vkQueueBindSparseImageMemory"))
-        return (void*) vkQueueBindSparseImageMemory;
+        return (PFN_vkVoidFunction) vkQueueBindSparseImageMemory;
     if (!strcmp(funcName, "vkCreateFence"))
-        return (void*) vkCreateFence;
+        return (PFN_vkVoidFunction) vkCreateFence;
     if (!strcmp(funcName, "vkGetFenceStatus"))
-        return (void*) vkGetFenceStatus;
+        return (PFN_vkVoidFunction) vkGetFenceStatus;
     if (!strcmp(funcName, "vkResetFences"))
-        return (void*) vkResetFences;
+        return (PFN_vkVoidFunction) vkResetFences;
     if (!strcmp(funcName, "vkWaitForFences"))
-        return (void*) vkWaitForFences;
+        return (PFN_vkVoidFunction) vkWaitForFences;
     if (!strcmp(funcName, "vkQueueWaitIdle"))
-        return (void*) vkQueueWaitIdle;
+        return (PFN_vkVoidFunction) vkQueueWaitIdle;
     if (!strcmp(funcName, "vkDeviceWaitIdle"))
-        return (void*) vkDeviceWaitIdle;
+        return (PFN_vkVoidFunction) vkDeviceWaitIdle;
     if (!strcmp(funcName, "vkCreateEvent"))
-        return (void*) vkCreateEvent;
+        return (PFN_vkVoidFunction) vkCreateEvent;
     if (!strcmp(funcName, "vkCreateQueryPool"))
-        return (void*) vkCreateQueryPool;
+        return (PFN_vkVoidFunction) vkCreateQueryPool;
     if (!strcmp(funcName, "vkCreateBuffer"))
-        return (void*) vkCreateBuffer;
+        return (PFN_vkVoidFunction) vkCreateBuffer;
     if (!strcmp(funcName, "vkCreateBufferView"))
-        return (void*) vkCreateBufferView;
+        return (PFN_vkVoidFunction) vkCreateBufferView;
     if (!strcmp(funcName, "vkCreateImage"))
-        return (void*) vkCreateImage;
+        return (PFN_vkVoidFunction) vkCreateImage;
     if (!strcmp(funcName, "vkCreateImageView"))
-        return (void*) vkCreateImageView;
+        return (PFN_vkVoidFunction) vkCreateImageView;
     if (!strcmp(funcName, "vkCreateAttachmentView"))
-        return (void*) vkCreateAttachmentView;
+        return (PFN_vkVoidFunction) vkCreateAttachmentView;
     if (!strcmp(funcName, "vkCreateShader"))
-        return (void*) vkCreateShader;
+        return (PFN_vkVoidFunction) vkCreateShader;
     if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
-        return (void*) vkCreateGraphicsPipelines;
+        return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
     if (!strcmp(funcName, "vkCreateComputePipelines"))
-        return (void*) vkCreateComputePipelines;
+        return (PFN_vkVoidFunction) vkCreateComputePipelines;
     if (!strcmp(funcName, "vkCreateSampler"))
-        return (void*) vkCreateSampler;
+        return (PFN_vkVoidFunction) vkCreateSampler;
     if (!strcmp(funcName, "vkCreateDynamicViewportState"))
-        return (void*) vkCreateDynamicViewportState;
+        return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
     if (!strcmp(funcName, "vkCreateDynamicRasterState"))
-        return (void*) vkCreateDynamicRasterState;
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
-        return (void*) vkCreateDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
     if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
-        return (void*) vkCreateDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkCreateDynamicDepthStencilState;
     if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (void*) vkCreateCommandBuffer;
+        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
-        return (void*) vkBeginCommandBuffer;
+        return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
-        return (void*) vkEndCommandBuffer;
+        return (PFN_vkVoidFunction) vkEndCommandBuffer;
     if (!strcmp(funcName, "vkResetCommandBuffer"))
-        return (void*) vkResetCommandBuffer;
+        return (PFN_vkVoidFunction) vkResetCommandBuffer;
     if (!strcmp(funcName, "vkCmdBindPipeline"))
-        return (void*) vkCmdBindPipeline;
+        return (PFN_vkVoidFunction) vkCmdBindPipeline;
     if (!strcmp(funcName, "vkCmdBindDynamicViewportState"))
-        return (void*) vkCmdBindDynamicViewportState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicViewportState;
     if (!strcmp(funcName, "vkCmdBindDynamicRasterState"))
-        return (void*) vkCmdBindDynamicRasterState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicRasterState;
     if (!strcmp(funcName, "vkCmdBindDynamicColorBlendState"))
-        return (void*) vkCmdBindDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicColorBlendState;
     if (!strcmp(funcName, "vkCmdBindDynamicDepthStencilState"))
-        return (void*) vkCmdBindDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkCmdBindDynamicDepthStencilState;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
-        return (void*) vkCmdBindDescriptorSets;
+        return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
     if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
-        return (void*) vkCmdBindVertexBuffers;
+        return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
     if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
-        return (void*) vkCmdBindIndexBuffer;
+        return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
     if (!strcmp(funcName, "vkCmdDrawIndirect"))
-        return (void*) vkCmdDrawIndirect;
+        return (PFN_vkVoidFunction) vkCmdDrawIndirect;
     if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
-        return (void*) vkCmdDrawIndexedIndirect;
+        return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
     if (!strcmp(funcName, "vkCmdDispatchIndirect"))
-        return (void*) vkCmdDispatchIndirect;
+        return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
     if (!strcmp(funcName, "vkCmdCopyBuffer"))
-        return (void*) vkCmdCopyBuffer;
+        return (PFN_vkVoidFunction) vkCmdCopyBuffer;
     if (!strcmp(funcName, "vkCmdCopyImage"))
-        return (void*) vkCmdCopyImage;
+        return (PFN_vkVoidFunction) vkCmdCopyImage;
     if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
-        return (void*) vkCmdCopyBufferToImage;
+        return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
     if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
-        return (void*) vkCmdCopyImageToBuffer;
+        return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
     if (!strcmp(funcName, "vkCmdUpdateBuffer"))
-        return (void*) vkCmdUpdateBuffer;
+        return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
     if (!strcmp(funcName, "vkCmdFillBuffer"))
-        return (void*) vkCmdFillBuffer;
+        return (PFN_vkVoidFunction) vkCmdFillBuffer;
     if (!strcmp(funcName, "vkCmdClearColorImage"))
-        return (void*) vkCmdClearColorImage;
+        return (PFN_vkVoidFunction) vkCmdClearColorImage;
     if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
-        return (void*) vkCmdClearDepthStencilImage;
+        return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage;
     if (!strcmp(funcName, "vkCmdResolveImage"))
-        return (void*) vkCmdResolveImage;
+        return (PFN_vkVoidFunction) vkCmdResolveImage;
     if (!strcmp(funcName, "vkCmdBeginQuery"))
-        return (void*) vkCmdBeginQuery;
+        return (PFN_vkVoidFunction) vkCmdBeginQuery;
     if (!strcmp(funcName, "vkCmdEndQuery"))
-        return (void*) vkCmdEndQuery;
+        return (PFN_vkVoidFunction) vkCmdEndQuery;
     if (!strcmp(funcName, "vkCmdResetQueryPool"))
-        return (void*) vkCmdResetQueryPool;
+        return (PFN_vkVoidFunction) vkCmdResetQueryPool;
     if (!strcmp(funcName, "vkGetDeviceQueue"))
-        return (void*) vkGetDeviceQueue;
+        return (PFN_vkVoidFunction) vkGetDeviceQueue;
 
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
     if (my_device_data->wsi_lunarg_enabled)
     {
         if (!strcmp(funcName, "vkCreateSwapChainWSI"))
-            return (void*) vkCreateSwapChainWSI;
+            return (PFN_vkVoidFunction) vkCreateSwapChainWSI;
         if (!strcmp(funcName, "vkDestroySwapChainWSI"))
-            return (void*) vkDestroySwapChainWSI;
+            return (PFN_vkVoidFunction) vkDestroySwapChainWSI;
         if (!strcmp(funcName, "vkGetSwapChainInfoWSI"))
-            return (void*) vkGetSwapChainInfoWSI;
+            return (PFN_vkVoidFunction) vkGetSwapChainInfoWSI;
     }
 
     VkLayerDispatchTable *pDisp  = get_dispatch_table(mem_tracker_device_table_map, dev);
@@ -3161,11 +3161,11 @@
     return pDisp->GetDeviceProcAddr(dev, funcName);
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(
     VkInstance       instance,
     const char       *funcName)
 {
-    void *fptr;
+    PFN_vkVoidFunction fptr;
     if (instance == NULL) {
         return NULL;
     }
@@ -3173,23 +3173,23 @@
     /* loader uses this to force layer initialization; instance object is wrapped */
     if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
         initInstanceTable(mem_tracker_instance_table_map, (const VkBaseLayerObject *) instance);
-        return (void *) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
     }
 
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (void *) vkDestroyInstance;
+        return (PFN_vkVoidFunction) vkDestroyInstance;
     if (!strcmp(funcName, "vkCreateInstance"))
-        return (void*) vkCreateInstance;
+        return (PFN_vkVoidFunction) vkCreateInstance;
     if (!strcmp(funcName, "vkGetPhysicalDeviceMemoryProperties"))
-        return (void*) vkGetPhysicalDeviceMemoryProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceMemoryProperties;
     if (!strcmp(funcName, "vkGetGlobalLayerProperties"))
-        return (void*) vkGetGlobalLayerProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalLayerProperties;
     if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
-        return (void*) vkGetGlobalExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalExtensionProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceLayerProperties"))
-        return (void*) vkGetPhysicalDeviceLayerProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceLayerProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
-        return (void*) vkGetPhysicalDeviceExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceExtensionProperties;
 
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 574e5c2..fd286b4 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -177,7 +177,7 @@
     }
 }
 
-VK_LAYER_EXPORT void * VKAPI multi1GetInstanceProcAddr(VkInstance inst, const char* pName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI multi1GetInstanceProcAddr(VkInstance inst, const char* pName)
 {
     VkBaseLayerObject* instw = (VkBaseLayerObject *) inst;
 
@@ -331,7 +331,7 @@
 
 }
 
-VK_LAYER_EXPORT void * VKAPI multi2GetDeviceProcAddr(VkDevice device, const char* pName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI multi2GetDeviceProcAddr(VkDevice device, const char* pName)
 {
     VkBaseLayerObject* devw = (VkBaseLayerObject *) device;
 
@@ -359,7 +359,7 @@
     }
 }
 
-VK_LAYER_EXPORT void * VKAPI multi2GetInstanceProcAddr(VkInstance inst, const char* pName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI multi2GetInstanceProcAddr(VkInstance inst, const char* pName)
 {
     VkBaseLayerObject* instw = (VkBaseLayerObject *) inst;
 
@@ -444,7 +444,7 @@
                                    pCount, pProperties);
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
 {
     // to find each layers GPA routine Loader will search via "<layerName>GetDeviceProcAddr"
     if (!strcmp("multi1GetDeviceProcAddr", pName))
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 4f9a163..d602b75 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -8443,7 +8443,7 @@
     PostCmdExecuteCommands(cmdBuffer, cmdBuffersCount);
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
 {
     if (device == NULL) {
         return NULL;
@@ -8452,171 +8452,171 @@
     /* loader uses this to force layer initialization; device object is wrapped */
     if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
         initDeviceTable(pc_device_table_map, (const VkBaseLayerObject *) device);
-        return (void*) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
     }
 
     if (!strcmp(funcName, "vkCreateDevice"))
-        return (void*) vkCreateDevice;
+        return (PFN_vkVoidFunction) vkCreateDevice;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (void*) vkDestroyDevice;
+        return (PFN_vkVoidFunction) vkDestroyDevice;
     if (!strcmp(funcName, "vkGetDeviceQueue"))
-        return (void*) vkGetDeviceQueue;
+        return (PFN_vkVoidFunction) vkGetDeviceQueue;
     if (!strcmp(funcName, "vkQueueSubmit"))
-        return (void*) vkQueueSubmit;
+        return (PFN_vkVoidFunction) vkQueueSubmit;
     if (!strcmp(funcName, "vkQueueWaitIdle"))
-        return (void*) vkQueueWaitIdle;
+        return (PFN_vkVoidFunction) vkQueueWaitIdle;
     if (!strcmp(funcName, "vkDeviceWaitIdle"))
-        return (void*) vkDeviceWaitIdle;
+        return (PFN_vkVoidFunction) vkDeviceWaitIdle;
     if (!strcmp(funcName, "vkAllocMemory"))
-        return (void*) vkAllocMemory;
+        return (PFN_vkVoidFunction) vkAllocMemory;
     if (!strcmp(funcName, "vkFreeMemory"))
-        return (void*) vkFreeMemory;
+        return (PFN_vkVoidFunction) vkFreeMemory;
     if (!strcmp(funcName, "vkMapMemory"))
-        return (void*) vkMapMemory;
+        return (PFN_vkVoidFunction) vkMapMemory;
     if (!strcmp(funcName, "vkUnmapMemory"))
-        return (void*) vkUnmapMemory;
+        return (PFN_vkVoidFunction) vkUnmapMemory;
     if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
-        return (void*) vkFlushMappedMemoryRanges;
+        return (PFN_vkVoidFunction) vkFlushMappedMemoryRanges;
     if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges"))
-        return (void*) vkInvalidateMappedMemoryRanges;
+        return (PFN_vkVoidFunction) vkInvalidateMappedMemoryRanges;
     if (!strcmp(funcName, "vkCreateFence"))
-        return (void*) vkCreateFence;
+        return (PFN_vkVoidFunction) vkCreateFence;
     if (!strcmp(funcName, "vkResetFences"))
-        return (void*) vkResetFences;
+        return (PFN_vkVoidFunction) vkResetFences;
     if (!strcmp(funcName, "vkGetFenceStatus"))
-        return (void*) vkGetFenceStatus;
+        return (PFN_vkVoidFunction) vkGetFenceStatus;
     if (!strcmp(funcName, "vkWaitForFences"))
-        return (void*) vkWaitForFences;
+        return (PFN_vkVoidFunction) vkWaitForFences;
     if (!strcmp(funcName, "vkCreateSemaphore"))
-        return (void*) vkCreateSemaphore;
+        return (PFN_vkVoidFunction) vkCreateSemaphore;
     if (!strcmp(funcName, "vkQueueSignalSemaphore"))
-        return (void*) vkQueueSignalSemaphore;
+        return (PFN_vkVoidFunction) vkQueueSignalSemaphore;
     if (!strcmp(funcName, "vkQueueWaitSemaphore"))
-        return (void*) vkQueueWaitSemaphore;
+        return (PFN_vkVoidFunction) vkQueueWaitSemaphore;
     if (!strcmp(funcName, "vkCreateEvent"))
-        return (void*) vkCreateEvent;
+        return (PFN_vkVoidFunction) vkCreateEvent;
     if (!strcmp(funcName, "vkGetEventStatus"))
-        return (void*) vkGetEventStatus;
+        return (PFN_vkVoidFunction) vkGetEventStatus;
     if (!strcmp(funcName, "vkSetEvent"))
-        return (void*) vkSetEvent;
+        return (PFN_vkVoidFunction) vkSetEvent;
     if (!strcmp(funcName, "vkResetEvent"))
-        return (void*) vkResetEvent;
+        return (PFN_vkVoidFunction) vkResetEvent;
     if (!strcmp(funcName, "vkCreateQueryPool"))
-        return (void*) vkCreateQueryPool;
+        return (PFN_vkVoidFunction) vkCreateQueryPool;
     if (!strcmp(funcName, "vkGetQueryPoolResults"))
-        return (void*) vkGetQueryPoolResults;
+        return (PFN_vkVoidFunction) vkGetQueryPoolResults;
     if (!strcmp(funcName, "vkCreateBuffer"))
-        return (void*) vkCreateBuffer;
+        return (PFN_vkVoidFunction) vkCreateBuffer;
     if (!strcmp(funcName, "vkCreateBufferView"))
-        return (void*) vkCreateBufferView;
+        return (PFN_vkVoidFunction) vkCreateBufferView;
     if (!strcmp(funcName, "vkCreateImage"))
-        return (void*) vkCreateImage;
+        return (PFN_vkVoidFunction) vkCreateImage;
     if (!strcmp(funcName, "vkGetImageSubresourceLayout"))
-        return (void*) vkGetImageSubresourceLayout;
+        return (PFN_vkVoidFunction) vkGetImageSubresourceLayout;
     if (!strcmp(funcName, "vkCreateImageView"))
-        return (void*) vkCreateImageView;
+        return (PFN_vkVoidFunction) vkCreateImageView;
     if (!strcmp(funcName, "vkCreateAttachmentView"))
-        return (void*) vkCreateAttachmentView;
+        return (PFN_vkVoidFunction) vkCreateAttachmentView;
     if (!strcmp(funcName, "vkCreateShader"))
-        return (void*) vkCreateShader;
+        return (PFN_vkVoidFunction) vkCreateShader;
     if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
-        return (void*) vkCreateGraphicsPipelines;
+        return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
     if (!strcmp(funcName, "vkCreateComputePipelines"))
-        return (void*) vkCreateComputePipelines;
+        return (PFN_vkVoidFunction) vkCreateComputePipelines;
     if (!strcmp(funcName, "vkCreatePipelineLayout"))
-        return (void*) vkCreatePipelineLayout;
+        return (PFN_vkVoidFunction) vkCreatePipelineLayout;
     if (!strcmp(funcName, "vkCreateSampler"))
-        return (void*) vkCreateSampler;
+        return (PFN_vkVoidFunction) vkCreateSampler;
     if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
-        return (void*) vkCreateDescriptorSetLayout;
+        return (PFN_vkVoidFunction) vkCreateDescriptorSetLayout;
     if (!strcmp(funcName, "vkCreateDescriptorPool"))
-        return (void*) vkCreateDescriptorPool;
+        return (PFN_vkVoidFunction) vkCreateDescriptorPool;
     if (!strcmp(funcName, "vkResetDescriptorPool"))
-        return (void*) vkResetDescriptorPool;
+        return (PFN_vkVoidFunction) vkResetDescriptorPool;
     if (!strcmp(funcName, "vkAllocDescriptorSets"))
-        return (void*) vkAllocDescriptorSets;
+        return (PFN_vkVoidFunction) vkAllocDescriptorSets;
     if (!strcmp(funcName, "vkCreateDynamicViewportState"))
-        return (void*) vkCreateDynamicViewportState;
+        return (PFN_vkVoidFunction) vkCreateDynamicViewportState;
     if (!strcmp(funcName, "vkCreateDynamicRasterState"))
-        return (void*) vkCreateDynamicRasterState;
+        return (PFN_vkVoidFunction) vkCreateDynamicRasterState;
     if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
-        return (void*) vkCreateDynamicColorBlendState;
+        return (PFN_vkVoidFunction) vkCreateDynamicColorBlendState;
     if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
-        return (void*) vkCreateDynamicDepthStencilState;
+        return (PFN_vkVoidFunction) vkCreateDynamicDepthStencilState;
     if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (void*) vkCreateCommandBuffer;
+        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
-        return (void*) vkBeginCommandBuffer;
+        return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
-        return (void*) vkEndCommandBuffer;
+        return (PFN_vkVoidFunction) vkEndCommandBuffer;
     if (!strcmp(funcName, "vkResetCommandBuffer"))
-        return (void*) vkResetCommandBuffer;
+        return (PFN_vkVoidFunction) vkResetCommandBuffer;
     if (!strcmp(funcName, "vkCmdBindPipeline"))
-        return (void*) vkCmdBindPipeline;
+        return (PFN_vkVoidFunction) vkCmdBindPipeline;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
-        return (void*) vkCmdBindDescriptorSets;
+        return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
     if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
-        return (void*) vkCmdBindVertexBuffers;
+        return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
     if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
-        return (void*) vkCmdBindIndexBuffer;
+        return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
     if (!strcmp(funcName, "vkCmdDraw"))
-        return (void*) vkCmdDraw;
+        return (PFN_vkVoidFunction) vkCmdDraw;
     if (!strcmp(funcName, "vkCmdDrawIndexed"))
-        return (void*) vkCmdDrawIndexed;
+        return (PFN_vkVoidFunction) vkCmdDrawIndexed;
     if (!strcmp(funcName, "vkCmdDrawIndirect"))
-        return (void*) vkCmdDrawIndirect;
+        return (PFN_vkVoidFunction) vkCmdDrawIndirect;
     if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
-        return (void*) vkCmdDrawIndexedIndirect;
+        return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
     if (!strcmp(funcName, "vkCmdDispatch"))
-        return (void*) vkCmdDispatch;
+        return (PFN_vkVoidFunction) vkCmdDispatch;
     if (!strcmp(funcName, "vkCmdDispatchIndirect"))
-        return (void*) vkCmdDispatchIndirect;
+        return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
     if (!strcmp(funcName, "vkCmdCopyBuffer"))
-        return (void*) vkCmdCopyBuffer;
+        return (PFN_vkVoidFunction) vkCmdCopyBuffer;
     if (!strcmp(funcName, "vkCmdCopyImage"))
-        return (void*) vkCmdCopyImage;
+        return (PFN_vkVoidFunction) vkCmdCopyImage;
     if (!strcmp(funcName, "vkCmdBlitImage"))
-        return (void*) vkCmdBlitImage;
+        return (PFN_vkVoidFunction) vkCmdBlitImage;
     if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
-        return (void*) vkCmdCopyBufferToImage;
+        return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
     if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
-        return (void*) vkCmdCopyImageToBuffer;
+        return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
     if (!strcmp(funcName, "vkCmdUpdateBuffer"))
-        return (void*) vkCmdUpdateBuffer;
+        return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
     if (!strcmp(funcName, "vkCmdFillBuffer"))
-        return (void*) vkCmdFillBuffer;
+        return (PFN_vkVoidFunction) vkCmdFillBuffer;
     if (!strcmp(funcName, "vkCmdClearColorImage"))
-        return (void*) vkCmdClearColorImage;
+        return (PFN_vkVoidFunction) vkCmdClearColorImage;
     if (!strcmp(funcName, "vkCmdResolveImage"))
-        return (void*) vkCmdResolveImage;
+        return (PFN_vkVoidFunction) vkCmdResolveImage;
     if (!strcmp(funcName, "vkCmdSetEvent"))
-        return (void*) vkCmdSetEvent;
+        return (PFN_vkVoidFunction) vkCmdSetEvent;
     if (!strcmp(funcName, "vkCmdResetEvent"))
-        return (void*) vkCmdResetEvent;
+        return (PFN_vkVoidFunction) vkCmdResetEvent;
     if (!strcmp(funcName, "vkCmdWaitEvents"))
-        return (void*) vkCmdWaitEvents;
+        return (PFN_vkVoidFunction) vkCmdWaitEvents;
     if (!strcmp(funcName, "vkCmdPipelineBarrier"))
-        return (void*) vkCmdPipelineBarrier;
+        return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
     if (!strcmp(funcName, "vkCmdBeginQuery"))
-        return (void*) vkCmdBeginQuery;
+        return (PFN_vkVoidFunction) vkCmdBeginQuery;
     if (!strcmp(funcName, "vkCmdEndQuery"))
-        return (void*) vkCmdEndQuery;
+        return (PFN_vkVoidFunction) vkCmdEndQuery;
     if (!strcmp(funcName, "vkCmdResetQueryPool"))
-        return (void*) vkCmdResetQueryPool;
+        return (PFN_vkVoidFunction) vkCmdResetQueryPool;
     if (!strcmp(funcName, "vkCmdWriteTimestamp"))
-        return (void*) vkCmdWriteTimestamp;
+        return (PFN_vkVoidFunction) vkCmdWriteTimestamp;
     if (!strcmp(funcName, "vkCmdCopyQueryPoolResults"))
-        return (void*) vkCmdCopyQueryPoolResults;
+        return (PFN_vkVoidFunction) vkCmdCopyQueryPoolResults;
     if (!strcmp(funcName, "vkCreateFramebuffer"))
-        return (void*) vkCreateFramebuffer;
+        return (PFN_vkVoidFunction) vkCreateFramebuffer;
     if (!strcmp(funcName, "vkCreateRenderPass"))
-        return (void*) vkCreateRenderPass;
+        return (PFN_vkVoidFunction) vkCreateRenderPass;
     if (!strcmp(funcName, "vkCmdBeginRenderPass"))
-        return (void*) vkCmdBeginRenderPass;
+        return (PFN_vkVoidFunction) vkCmdBeginRenderPass;
     if (!strcmp(funcName, "vkCmdNextSubpass"))
-        return (void*) vkCmdNextSubpass;
+        return (PFN_vkVoidFunction) vkCmdNextSubpass;
     if (!strcmp(funcName, "vkCmdEndRenderPass"))
-        return (void*) vkCmdEndRenderPass;
+        return (PFN_vkVoidFunction) vkCmdEndRenderPass;
 
     {
         if (get_dispatch_table(pc_device_table_map, device)->GetDeviceProcAddr == NULL)
@@ -8625,7 +8625,7 @@
     }
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
 {
     if (instance == NULL) {
         return NULL;
@@ -8634,34 +8634,34 @@
     /* loader uses this to force layer initialization; instance object is wrapped */
     if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
         initInstanceTable(pc_instance_table_map, (const VkBaseLayerObject *) instance);
-        return (void *) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
     }
 
     if (!strcmp(funcName, "vkCreateInstance"))
-        return (void*) vkCreateInstance;
+        return (PFN_vkVoidFunction) vkCreateInstance;
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (void*) vkDestroyInstance;
+        return (PFN_vkVoidFunction) vkDestroyInstance;
     if (!strcmp(funcName, "vkEnumeratePhysicalDevices"))
-        return (void*) vkEnumeratePhysicalDevices;
+        return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;
     if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
-        return (void*) vkGetPhysicalDeviceProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures"))
-        return (void*) vkGetPhysicalDeviceFeatures;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceFeatures;
     if (!strcmp(funcName, "vkGetPhysicalDeviceFormatProperties"))
-        return (void*) vkGetPhysicalDeviceFormatProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceFormatProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceLimits"))
-        return (void*) vkGetPhysicalDeviceLimits;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceLimits;
     if (!strcmp(funcName, "vkGetGlobalLayerProperties"))
-        return (void*) vkGetGlobalLayerProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalLayerProperties;
     if (!strcmp(funcName, "vkGetGlobalExtensionProperties"))
-        return (void*) vkGetGlobalExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetGlobalExtensionProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceLayerProperties"))
-        return (void*) vkGetPhysicalDeviceLayerProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceLayerProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceExtensionProperties"))
-        return (void*) vkGetPhysicalDeviceExtensionProperties;
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceExtensionProperties;
 
     layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    void* fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
+    PFN_vkVoidFunction fptr = debug_report_get_instance_proc_addr(data->report_data, funcName);
     if(fptr)
         return fptr;
 
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 69b99f3..ec7db3d 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -520,7 +520,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
     VkDevice         dev,
     const char       *funcName)
 {
@@ -556,7 +556,7 @@
 }
 
 
-VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
 {
     return NULL;
 #if 0
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 1425b67..25cd7ce 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -1074,7 +1074,7 @@
     return res;
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
 {
     if (dev == NULL)
         return NULL;
@@ -1082,12 +1082,12 @@
     /* loader uses this to force layer initialization; device object is wrapped */
     if (!strcmp("vkGetDeviceProcAddr", funcName)) {
         initDeviceTable(shader_checker_device_table_map, (const VkBaseLayerObject *) dev);
-        return (void *) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
     }
 
 #define ADD_HOOK(fn)    \
     if (!strncmp(#fn, funcName, sizeof(#fn))) \
-        return (void *) fn
+        return (PFN_vkVoidFunction) fn
 
     ADD_HOOK(vkCreateDevice);
     ADD_HOOK(vkCreateShaderModule);
@@ -1105,20 +1105,20 @@
     }
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
+VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
 {
-    void *fptr;
+    PFN_vkVoidFunction fptr;
 
     if (instance == NULL)
         return NULL;
 
     if (!strcmp("vkGetInstanceProcAddr", funcName)) {
         initInstanceTable(shader_checker_instance_table_map, (const VkBaseLayerObject *) instance);
-        return (void *) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
     }
 #define ADD_HOOK(fn)    \
     if (!strncmp(#fn, funcName, sizeof(#fn))) \
-        return (void *) fn
+        return (PFN_vkVoidFunction) fn
 
     ADD_HOOK(vkCreateInstance);
     ADD_HOOK(vkDestroyInstance);
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index 4ba1027..f2952e9 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -198,7 +198,7 @@
     }
 }
 
-static inline void* debug_report_get_instance_proc_addr(
+static inline PFN_vkVoidFunction debug_report_get_instance_proc_addr(
         debug_report_data              *debug_data,
         const char                     *funcName)
 {
@@ -207,10 +207,10 @@
     }
 
     if (!strcmp(funcName, "vkDbgCreateMsgCallback")) {
-        return (void *) vkDbgCreateMsgCallback;
+        return (PFN_vkVoidFunction) vkDbgCreateMsgCallback;
     }
     if (!strcmp(funcName, "vkDbgDestroyMsgCallback")) {
-        return (void *) vkDbgDestroyMsgCallback;
+        return (PFN_vkVoidFunction) vkDbgDestroyMsgCallback;
     }
 
     return NULL;
diff --git a/layers/vk_layer_msg.h b/layers/vk_layer_msg.h
index 13c9b8c..3b08a2c 100644
--- a/layers/vk_layer_msg.h
+++ b/layers/vk_layer_msg.h
@@ -105,7 +105,7 @@
     table->DbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) gpa(inst, "vkDbgDestroyMsgCallback");
 }
 
-static void* msg_callback_get_proc_addr(
+static PFN_vkVoidFunction msg_callback_get_proc_addr(
         const char      *funcName)
 {
     if (!g_DEBUG_REPORT) {
@@ -113,10 +113,10 @@
     }
 
     if (!strcmp(funcName, "vkDbgCreateMsgCallback")) {
-        return (void *) vkDbgCreateMsgCallback;
+        return (PFN_vkVoidFunction) vkDbgCreateMsgCallback;
     }
     if (!strcmp(funcName, "vkDbgDestroyMsgCallback")) {
-        return (void *) vkDbgDestroyMsgCallback;
+        return (PFN_vkVoidFunction) vkDbgDestroyMsgCallback;
     }
 
     return NULL;
diff --git a/loader/loader.c b/loader/loader.c
index 9e530e7..bb1ba99 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -64,7 +64,7 @@
 
 struct loader_struct loader = {0};
 
-static void * VKAPI loader_GetInstanceProcAddr(VkInstance instance, const char * pName);
+static PFN_vkVoidFunction VKAPI loader_GetInstanceProcAddr(VkInstance instance, const char * pName);
 static bool loader_init_ext_list(struct loader_extension_list *ext_info);
 
 enum loader_debug {
@@ -1790,7 +1790,7 @@
 
 }
 
-static void* VKAPI loader_gpa_instance_internal(VkInstance inst, const char * pName)
+static PFN_vkVoidFunction VKAPI loader_gpa_instance_internal(VkInstance inst, const char * pName)
 {
     // inst is not wrapped
     if (inst == VK_NULL_HANDLE) {
@@ -2182,12 +2182,12 @@
     return VK_SUCCESS;
 }
 
-static void * VKAPI loader_GetDeviceChainProcAddr(VkDevice device, const char * name)
+static PFN_vkVoidFunction VKAPI loader_GetDeviceChainProcAddr(VkDevice device, const char * name)
 {
     if (!strcmp(name, "vkGetDeviceProcAddr"))
-        return (void *) loader_GetDeviceChainProcAddr;
+        return (PFN_vkVoidFunction) loader_GetDeviceChainProcAddr;
     if (!strcmp(name, "vkCreateDevice"))
-        return (void *) scratch_vkCreateDevice;
+        return (PFN_vkVoidFunction) scratch_vkCreateDevice;
 
     struct loader_device *found_dev;
     struct loader_icd *icd = loader_get_icd_and_device(device, &found_dev);
@@ -2824,7 +2824,7 @@
     return res;
 }
 
-static void * VKAPI loader_GetInstanceProcAddr(VkInstance instance, const char * pName)
+static PFN_vkVoidFunction VKAPI loader_GetInstanceProcAddr(VkInstance instance, const char * pName)
 {
     if (instance == VK_NULL_HANDLE)
         return NULL;
@@ -2861,12 +2861,12 @@
     return NULL;
 }
 
-LOADER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance instance, const char * pName)
+LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char * pName)
 {
     return loader_GetInstanceProcAddr(instance, pName);
 }
 
-static void * VKAPI loader_GetDeviceProcAddr(VkDevice device, const char * pName)
+static PFN_vkVoidFunction VKAPI loader_GetDeviceProcAddr(VkDevice device, const char * pName)
 {
     if (device == VK_NULL_HANDLE) {
         return NULL;
@@ -2903,7 +2903,7 @@
     }
 }
 
-LOADER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char * pName)
+LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char * pName)
 {
     return loader_GetDeviceProcAddr(device, pName);
 }
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index dad002c..c7876ca 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -157,7 +157,7 @@
     const PhysicalDevice &phy() const { return phy_; }
 
     // vkGetDeviceProcAddr()
-    void *get_proc(const char *name) const { return vkGetDeviceProcAddr(handle(), name); }
+    PFN_vkVoidFunction get_proc(const char *name) const { return vkGetDeviceProcAddr(handle(), name); }
 
     // vkGetDeviceQueue()
     const std::vector<Queue *> &graphics_queues() const { return queues_[GRAPHICS]; }
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 3f7e7b3..8c4b365 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -294,13 +294,13 @@
         lookups = []
         for proto in intercepted:
             lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
-            lookups.append("    return (void*) %s%s;" %
+            lookups.append("    return (PFN_vkVoidFunction) %s%s;" %
                     (prefix, proto.name))
 
         # add customized layer_intercept_proc
         body = []
         body.append('%s' % self.lineinfo.get())
-        body.append("static inline void* layer_intercept_proc(const char *name)")
+        body.append("static inline PFN_vkVoidFunction layer_intercept_proc(const char *name)")
         body.append("{")
         body.append(generate_get_proc_addr_check("name"))
         body.append("")
@@ -320,9 +320,9 @@
             if proto.name == "CreateDevice":
                 continue
             lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
-            lookups.append("    return (void*) %s%s;" % (prefix, proto.name))
+            lookups.append("    return (PFN_vkVoidFunction) %s%s;" % (prefix, proto.name))
 
-        body.append("static inline void* layer_intercept_instance_proc(const char *name)")
+        body.append("static inline PFN_vkVoidFunction layer_intercept_instance_proc(const char *name)")
         body.append("{")
         body.append(generate_get_proc_addr_check("name"))
         body.append("")
@@ -348,16 +348,16 @@
 # New style of GPA Functions for the new layer_data/layer_logging changes
 #
         if self.layer_name == 'ObjectTracker':
-            func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)\n"
+            func_body.append("VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)\n"
                              "{\n"
-                             "    void* addr;\n"
+                             "    PFN_vkVoidFunction addr;\n"
                              "    if (device == VK_NULL_HANDLE) {\n"
                              "        return NULL;\n"
                              "    }\n"
                              "    /* loader uses this to force layer initialization; device object is wrapped */\n"
                              "    if (!strcmp(\"vkGetDeviceProcAddr\", funcName)) {\n"
                              "        initDeviceTable(%s_device_table_map, (const VkBaseLayerObject *) device);\n"
-                             "        return (void *) vkGetDeviceProcAddr;\n"
+                             "        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;\n"
                              "    }\n\n"
                              "    addr = layer_intercept_proc(funcName);\n"
                              "    if (addr)\n"
@@ -372,23 +372,23 @@
                         extra_space = "    "
                     for ext_name in ext_list:
                         func_body.append('    %sif (!strcmp("%s", funcName))\n'
-                                         '        %sreturn reinterpret_cast<void*>(%s);' % (extra_space, ext_name, extra_space, ext_name))
+                                         '        %sreturn reinterpret_cast<PFN_vkVoidFunction>(%s);' % (extra_space, ext_name, extra_space, ext_name))
                     if 0 != len(ext_enable):
                         func_body.append('    }\n')
             func_body.append("\n    if (get_dispatch_table(%s_device_table_map, device)->GetDeviceProcAddr == NULL)\n"
                              "        return NULL;\n"
                              "    return get_dispatch_table(%s_device_table_map, device)->GetDeviceProcAddr(device, funcName);\n"
                              "}\n" % (self.layer_name, self.layer_name))
-            func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
+            func_body.append("VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
                              "{\n"
-                             "    void* addr;\n"
+                             "    PFN_vkVoidFunction addr;\n"
                              "    if (instance == VK_NULL_HANDLE) {\n"
                              "        return NULL;\n"
                              "    }\n"
                              "    /* loader uses this to force layer initialization; instance object is wrapped */\n"
                              "    if (!strcmp(\"vkGetInstanceProcAddr\", funcName)) {\n"
                              "        initInstanceTable(%s_instance_table_map, (const VkBaseLayerObject *) instance);\n"
-                             "        return (void *) vkGetInstanceProcAddr;\n"
+                             "        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;\n"
                              "    }\n\n"
                              "    addr = layer_intercept_instance_proc(funcName);\n"
                              "    if (addr) {\n"
@@ -413,9 +413,9 @@
 # TODO::  Old-style GPA Functions -- no local storage, no new logging mechanism.  Left for compatibility.
 #
             func_body.append('%s' % self.lineinfo.get())
-            func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)\n"
+            func_body.append("VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)\n"
                              "{\n"
-                             "    void* addr;\n"
+                             "    PFN_vkVoidFunction addr;\n"
                              "    if (device == VK_NULL_HANDLE) {\n"
                              "        return NULL;\n"
                              "    }\n"
@@ -423,7 +423,7 @@
                              "    /* loader uses this to force layer initialization; device object is wrapped */\n"
                              "    if (!strcmp(\"vkGetDeviceProcAddr\", funcName)) {\n"
                              "        initDeviceTable((const VkBaseLayerObject *) device);\n"
-                             "        return (void *) vkGetDeviceProcAddr;\n"
+                             "        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;\n"
                              "    }\n\n"
                              "    addr = layer_intercept_proc(funcName);\n"
                              "    if (addr)\n"
@@ -439,7 +439,7 @@
                         extra_space = "    "
                     for ext_name in ext_list:
                         func_body.append('    %sif (!strcmp("%s", funcName))\n'
-                                         '            return reinterpret_cast<void*>(%s);' % (extra_space, ext_name, ext_name))
+                                         '            return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (extra_space, ext_name, ext_name))
                     if 0 != len(ext_enable):
                         func_body.append('    }')
             func_body.append('%s' % self.lineinfo.get())
@@ -449,9 +449,9 @@
                              "        return pDisp->GetDeviceProcAddr(device, funcName);\n"
                              "    }\n"
                              "}\n")
-            func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
+            func_body.append("VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
                              "{\n"
-                             "    void* addr;\n"
+                             "    PFN_vkVoidFunction addr;\n"
                              "    if (instance == VK_NULL_HANDLE) {\n"
                              "        return NULL;\n"
                              "    }\n"
@@ -459,7 +459,7 @@
                              "    /* loader uses this to force layer initialization; instance object is wrapped */\n"
                              "    if (!strcmp(\"vkGetInstanceProcAddr\", funcName)) {\n"
                              "        initInstanceTable((const VkBaseLayerObject *) instance);\n"
-                             "        return (void *) vkGetInstanceProcAddr;\n"
+                             "        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;\n"
                              "    }\n\n"
                              "    addr = layer_intercept_instance_proc(funcName);\n"
                              "    if (addr)\n"
@@ -467,7 +467,7 @@
             if 0 != len(instance_extensions):
                 for ext_name in instance_extensions:
                     func_body.append("    {\n"
-                                     "        void *fptr;\n"
+                                     "        PFN_vkVoidFunction fptr;\n"
                                      "        fptr = %s(funcName);\n"
                                      "        if (fptr) return fptr;\n"
                                      "    }\n" % ext_name)
diff --git a/vulkan.py b/vulkan.py
index 5c11534..6007555 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -241,11 +241,11 @@
             [Param("VkPhysicalDevice", "physicalDevice"),
              Param("VkPhysicalDeviceLimits*", "pLimits")]),
 
-        Proto("void*", "GetInstanceProcAddr",
+        Proto("PFN_vkVoidFunction", "GetInstanceProcAddr",
             [Param("VkInstance", "instance"),
              Param("const char*", "pName")]),
 
-        Proto("void*", "GetDeviceProcAddr",
+        Proto("PFN_vkVoidFunction", "GetDeviceProcAddr",
             [Param("VkDevice", "device"),
              Param("const char*", "pName")]),